mavsdk-types 1.0.0

package/geofence/GeofenceServiceClientPb.ts

@@ -0,0 +1,125 @@
+/**
+ * @fileoverview gRPC-Web generated client stub for mavsdk.rpc.geofence
+ * @enhanceable
+ * @public
+ */
+
+// GENERATED CODE -- DO NOT EDIT!
+
+
+/* eslint-disable */
+// @ts-nocheck
+
+
+import * as grpcWeb from 'grpc-web';
+
+import * as geofence_geofence_pb from '../geofence/geofence_pb';
+
+
+export class GeofenceServiceClient {
+  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;
+  }
+
+  methodDescriptorUploadGeofence = new grpcWeb.MethodDescriptor(
+    '/mavsdk.rpc.geofence.GeofenceService/UploadGeofence',
+    grpcWeb.MethodType.UNARY,
+    geofence_geofence_pb.UploadGeofenceRequest,
+    geofence_geofence_pb.UploadGeofenceResponse,
+    (request: geofence_geofence_pb.UploadGeofenceRequest) => {
+      return request.serializeBinary();
+    },
+    geofence_geofence_pb.UploadGeofenceResponse.deserializeBinary
+  );
+
+  uploadGeofence(
+    request: geofence_geofence_pb.UploadGeofenceRequest,
+    metadata: grpcWeb.Metadata | null): Promise<geofence_geofence_pb.UploadGeofenceResponse>;
+
+  uploadGeofence(
+    request: geofence_geofence_pb.UploadGeofenceRequest,
+    metadata: grpcWeb.Metadata | null,
+    callback: (err: grpcWeb.RpcError,
+               response: geofence_geofence_pb.UploadGeofenceResponse) => void): grpcWeb.ClientReadableStream<geofence_geofence_pb.UploadGeofenceResponse>;
+
+  uploadGeofence(
+    request: geofence_geofence_pb.UploadGeofenceRequest,
+    metadata: grpcWeb.Metadata | null,
+    callback?: (err: grpcWeb.RpcError,
+               response: geofence_geofence_pb.UploadGeofenceResponse) => void) {
+    if (callback !== undefined) {
+      return this.client_.rpcCall(
+        this.hostname_ +
+          '/mavsdk.rpc.geofence.GeofenceService/UploadGeofence',
+        request,
+        metadata || {},
+        this.methodDescriptorUploadGeofence,
+        callback);
+    }
+    return this.client_.unaryCall(
+    this.hostname_ +
+      '/mavsdk.rpc.geofence.GeofenceService/UploadGeofence',
+    request,
+    metadata || {},
+    this.methodDescriptorUploadGeofence);
+  }
+
+  methodDescriptorClearGeofence = new grpcWeb.MethodDescriptor(
+    '/mavsdk.rpc.geofence.GeofenceService/ClearGeofence',
+    grpcWeb.MethodType.UNARY,
+    geofence_geofence_pb.ClearGeofenceRequest,
+    geofence_geofence_pb.ClearGeofenceResponse,
+    (request: geofence_geofence_pb.ClearGeofenceRequest) => {
+      return request.serializeBinary();
+    },
+    geofence_geofence_pb.ClearGeofenceResponse.deserializeBinary
+  );
+
+  clearGeofence(
+    request: geofence_geofence_pb.ClearGeofenceRequest,
+    metadata: grpcWeb.Metadata | null): Promise<geofence_geofence_pb.ClearGeofenceResponse>;
+
+  clearGeofence(
+    request: geofence_geofence_pb.ClearGeofenceRequest,
+    metadata: grpcWeb.Metadata | null,
+    callback: (err: grpcWeb.RpcError,
+               response: geofence_geofence_pb.ClearGeofenceResponse) => void): grpcWeb.ClientReadableStream<geofence_geofence_pb.ClearGeofenceResponse>;
+
+  clearGeofence(
+    request: geofence_geofence_pb.ClearGeofenceRequest,
+    metadata: grpcWeb.Metadata | null,
+    callback?: (err: grpcWeb.RpcError,
+               response: geofence_geofence_pb.ClearGeofenceResponse) => void) {
+    if (callback !== undefined) {
+      return this.client_.rpcCall(
+        this.hostname_ +
+          '/mavsdk.rpc.geofence.GeofenceService/ClearGeofence',
+        request,
+        metadata || {},
+        this.methodDescriptorClearGeofence,
+        callback);
+    }
+    return this.client_.unaryCall(
+    this.hostname_ +
+      '/mavsdk.rpc.geofence.GeofenceService/ClearGeofence',
+    request,
+    metadata || {},
+    this.methodDescriptorClearGeofence);
+  }
+
+}
+

package/geofence/geofence_pb.d.ts

@@ -0,0 +1,216 @@
+import * as jspb from 'google-protobuf'
+
+import * as mavsdk_options_pb from '../mavsdk_options_pb';
+
+
+export class Point extends jspb.Message {
+  getLatitudeDeg(): number;
+  setLatitudeDeg(value: number): Point;
+
+  getLongitudeDeg(): number;
+  setLongitudeDeg(value: number): Point;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): Point.AsObject;
+  static toObject(includeInstance: boolean, msg: Point): Point.AsObject;
+  static serializeBinaryToWriter(message: Point, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): Point;
+  static deserializeBinaryFromReader(message: Point, reader: jspb.BinaryReader): Point;
+}
+
+export namespace Point {
+  export type AsObject = {
+    latitudeDeg: number,
+    longitudeDeg: number,
+  }
+}
+
+export class Polygon extends jspb.Message {
+  getPointsList(): Array<Point>;
+  setPointsList(value: Array<Point>): Polygon;
+  clearPointsList(): Polygon;
+  addPoints(value?: Point, index?: number): Point;
+
+  getFenceType(): FenceType;
+  setFenceType(value: FenceType): Polygon;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): Polygon.AsObject;
+  static toObject(includeInstance: boolean, msg: Polygon): Polygon.AsObject;
+  static serializeBinaryToWriter(message: Polygon, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): Polygon;
+  static deserializeBinaryFromReader(message: Polygon, reader: jspb.BinaryReader): Polygon;
+}
+
+export namespace Polygon {
+  export type AsObject = {
+    pointsList: Array<Point.AsObject>,
+    fenceType: FenceType,
+  }
+}
+
+export class Circle extends jspb.Message {
+  getPoint(): Point | undefined;
+  setPoint(value?: Point): Circle;
+  hasPoint(): boolean;
+  clearPoint(): Circle;
+
+  getRadius(): number;
+  setRadius(value: number): Circle;
+
+  getFenceType(): FenceType;
+  setFenceType(value: FenceType): Circle;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): Circle.AsObject;
+  static toObject(includeInstance: boolean, msg: Circle): Circle.AsObject;
+  static serializeBinaryToWriter(message: Circle, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): Circle;
+  static deserializeBinaryFromReader(message: Circle, reader: jspb.BinaryReader): Circle;
+}
+
+export namespace Circle {
+  export type AsObject = {
+    point?: Point.AsObject,
+    radius: number,
+    fenceType: FenceType,
+  }
+}
+
+export class GeofenceData extends jspb.Message {
+  getPolygonsList(): Array<Polygon>;
+  setPolygonsList(value: Array<Polygon>): GeofenceData;
+  clearPolygonsList(): GeofenceData;
+  addPolygons(value?: Polygon, index?: number): Polygon;
+
+  getCirclesList(): Array<Circle>;
+  setCirclesList(value: Array<Circle>): GeofenceData;
+  clearCirclesList(): GeofenceData;
+  addCircles(value?: Circle, index?: number): Circle;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): GeofenceData.AsObject;
+  static toObject(includeInstance: boolean, msg: GeofenceData): GeofenceData.AsObject;
+  static serializeBinaryToWriter(message: GeofenceData, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GeofenceData;
+  static deserializeBinaryFromReader(message: GeofenceData, reader: jspb.BinaryReader): GeofenceData;
+}
+
+export namespace GeofenceData {
+  export type AsObject = {
+    polygonsList: Array<Polygon.AsObject>,
+    circlesList: Array<Circle.AsObject>,
+  }
+}
+
+export class UploadGeofenceRequest extends jspb.Message {
+  getGeofenceData(): GeofenceData | undefined;
+  setGeofenceData(value?: GeofenceData): UploadGeofenceRequest;
+  hasGeofenceData(): boolean;
+  clearGeofenceData(): UploadGeofenceRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): UploadGeofenceRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: UploadGeofenceRequest): UploadGeofenceRequest.AsObject;
+  static serializeBinaryToWriter(message: UploadGeofenceRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): UploadGeofenceRequest;
+  static deserializeBinaryFromReader(message: UploadGeofenceRequest, reader: jspb.BinaryReader): UploadGeofenceRequest;
+}
+
+export namespace UploadGeofenceRequest {
+  export type AsObject = {
+    geofenceData?: GeofenceData.AsObject,
+  }
+}
+
+export class UploadGeofenceResponse extends jspb.Message {
+  getGeofenceResult(): GeofenceResult | undefined;
+  setGeofenceResult(value?: GeofenceResult): UploadGeofenceResponse;
+  hasGeofenceResult(): boolean;
+  clearGeofenceResult(): UploadGeofenceResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): UploadGeofenceResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: UploadGeofenceResponse): UploadGeofenceResponse.AsObject;
+  static serializeBinaryToWriter(message: UploadGeofenceResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): UploadGeofenceResponse;
+  static deserializeBinaryFromReader(message: UploadGeofenceResponse, reader: jspb.BinaryReader): UploadGeofenceResponse;
+}
+
+export namespace UploadGeofenceResponse {
+  export type AsObject = {
+    geofenceResult?: GeofenceResult.AsObject,
+  }
+}
+
+export class ClearGeofenceRequest extends jspb.Message {
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ClearGeofenceRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: ClearGeofenceRequest): ClearGeofenceRequest.AsObject;
+  static serializeBinaryToWriter(message: ClearGeofenceRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ClearGeofenceRequest;
+  static deserializeBinaryFromReader(message: ClearGeofenceRequest, reader: jspb.BinaryReader): ClearGeofenceRequest;
+}
+
+export namespace ClearGeofenceRequest {
+  export type AsObject = {
+  }
+}
+
+export class ClearGeofenceResponse extends jspb.Message {
+  getGeofenceResult(): GeofenceResult | undefined;
+  setGeofenceResult(value?: GeofenceResult): ClearGeofenceResponse;
+  hasGeofenceResult(): boolean;
+  clearGeofenceResult(): ClearGeofenceResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ClearGeofenceResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: ClearGeofenceResponse): ClearGeofenceResponse.AsObject;
+  static serializeBinaryToWriter(message: ClearGeofenceResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ClearGeofenceResponse;
+  static deserializeBinaryFromReader(message: ClearGeofenceResponse, reader: jspb.BinaryReader): ClearGeofenceResponse;
+}
+
+export namespace ClearGeofenceResponse {
+  export type AsObject = {
+    geofenceResult?: GeofenceResult.AsObject,
+  }
+}
+
+export class GeofenceResult extends jspb.Message {
+  getResult(): GeofenceResult.Result;
+  setResult(value: GeofenceResult.Result): GeofenceResult;
+
+  getResultStr(): string;
+  setResultStr(value: string): GeofenceResult;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): GeofenceResult.AsObject;
+  static toObject(includeInstance: boolean, msg: GeofenceResult): GeofenceResult.AsObject;
+  static serializeBinaryToWriter(message: GeofenceResult, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GeofenceResult;
+  static deserializeBinaryFromReader(message: GeofenceResult, reader: jspb.BinaryReader): GeofenceResult;
+}
+
+export namespace GeofenceResult {
+  export type AsObject = {
+    result: GeofenceResult.Result,
+    resultStr: string,
+  }
+
+  export enum Result { 
+    RESULT_UNKNOWN = 0,
+    RESULT_SUCCESS = 1,
+    RESULT_ERROR = 2,
+    RESULT_TOO_MANY_GEOFENCE_ITEMS = 3,
+    RESULT_BUSY = 4,
+    RESULT_TIMEOUT = 5,
+    RESULT_INVALID_ARGUMENT = 6,
+    RESULT_NO_SYSTEM = 7,
+  }
+}
+
+export enum FenceType { 
+  FENCE_TYPE_INCLUSION = 0,
+  FENCE_TYPE_EXCLUSION = 1,
+}