@dronedeploy/rocos-js-sdk 0.0.1 → 2.6.1

package/grpc/robot-control/conker_grpc_pb.js

@@ -0,0 +1,143 @@
+// GENERATED CODE -- DO NOT EDIT!
+
+'use strict';
+var grpc = require('@grpc/grpc-js');
+var conker_pb = require('./conker_pb.js');
+
+function serialize_conker_v1_ConnectRequest(arg) {
+  if (!(arg instanceof conker_pb.ConnectRequest)) {
+    throw new Error('Expected argument of type conker.v1.ConnectRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_conker_v1_ConnectRequest(buffer_arg) {
+  return conker_pb.ConnectRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_conker_v1_ControlAck(arg) {
+  if (!(arg instanceof conker_pb.ControlAck)) {
+    throw new Error('Expected argument of type conker.v1.ControlAck');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_conker_v1_ControlAck(buffer_arg) {
+  return conker_pb.ControlAck.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_conker_v1_ControlEnd(arg) {
+  if (!(arg instanceof conker_pb.ControlEnd)) {
+    throw new Error('Expected argument of type conker.v1.ControlEnd');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_conker_v1_ControlEnd(buffer_arg) {
+  return conker_pb.ControlEnd.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_conker_v1_ControlMessage(arg) {
+  if (!(arg instanceof conker_pb.ControlMessage)) {
+    throw new Error('Expected argument of type conker.v1.ControlMessage');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_conker_v1_ControlMessage(buffer_arg) {
+  return conker_pb.ControlMessage.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_conker_v1_StatusMessage(arg) {
+  if (!(arg instanceof conker_pb.StatusMessage)) {
+    throw new Error('Expected argument of type conker.v1.StatusMessage');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_conker_v1_StatusMessage(buffer_arg) {
+  return conker_pb.StatusMessage.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_conker_v1_StatusRequest(arg) {
+  if (!(arg instanceof conker_pb.StatusRequest)) {
+    throw new Error('Expected argument of type conker.v1.StatusRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_conker_v1_StatusRequest(buffer_arg) {
+  return conker_pb.StatusRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+
+var RobotControlService = exports.RobotControlService = {
+  connectRobot: {
+    path: '/conker.v1.RobotControl/ConnectRobot',
+    requestStream: false,
+    responseStream: true,
+    requestType: conker_pb.ConnectRequest,
+    responseType: conker_pb.ControlMessage,
+    requestSerialize: serialize_conker_v1_ConnectRequest,
+    requestDeserialize: deserialize_conker_v1_ConnectRequest,
+    responseSerialize: serialize_conker_v1_ControlMessage,
+    responseDeserialize: deserialize_conker_v1_ControlMessage,
+  },
+  connectRobotWithAckStream: {
+    path: '/conker.v1.RobotControl/ConnectRobotWithAckStream',
+    requestStream: true,
+    responseStream: true,
+    requestType: conker_pb.ControlAck,
+    responseType: conker_pb.ControlMessage,
+    requestSerialize: serialize_conker_v1_ControlAck,
+    requestDeserialize: deserialize_conker_v1_ControlAck,
+    responseSerialize: serialize_conker_v1_ControlMessage,
+    responseDeserialize: deserialize_conker_v1_ControlMessage,
+  },
+  controlRobot: {
+    path: '/conker.v1.RobotControl/ControlRobot',
+    requestStream: true,
+    responseStream: false,
+    requestType: conker_pb.ControlMessage,
+    responseType: conker_pb.ControlEnd,
+    requestSerialize: serialize_conker_v1_ControlMessage,
+    requestDeserialize: deserialize_conker_v1_ControlMessage,
+    responseSerialize: serialize_conker_v1_ControlEnd,
+    responseDeserialize: deserialize_conker_v1_ControlEnd,
+  },
+  controlRobotCall: {
+    path: '/conker.v1.RobotControl/ControlRobotCall',
+    requestStream: false,
+    responseStream: false,
+    requestType: conker_pb.ControlMessage,
+    responseType: conker_pb.ControlAck,
+    requestSerialize: serialize_conker_v1_ControlMessage,
+    requestDeserialize: deserialize_conker_v1_ControlMessage,
+    responseSerialize: serialize_conker_v1_ControlAck,
+    responseDeserialize: deserialize_conker_v1_ControlAck,
+  },
+  controlRobotCallWithAckStream: {
+    path: '/conker.v1.RobotControl/ControlRobotCallWithAckStream',
+    requestStream: false,
+    responseStream: true,
+    requestType: conker_pb.ControlMessage,
+    responseType: conker_pb.ControlAck,
+    requestSerialize: serialize_conker_v1_ControlMessage,
+    requestDeserialize: deserialize_conker_v1_ControlMessage,
+    responseSerialize: serialize_conker_v1_ControlAck,
+    responseDeserialize: deserialize_conker_v1_ControlAck,
+  },
+  status: {
+    path: '/conker.v1.RobotControl/Status',
+    requestStream: false,
+    responseStream: false,
+    requestType: conker_pb.StatusRequest,
+    responseType: conker_pb.StatusMessage,
+    requestSerialize: serialize_conker_v1_StatusRequest,
+    requestDeserialize: deserialize_conker_v1_StatusRequest,
+    responseSerialize: serialize_conker_v1_StatusMessage,
+    responseDeserialize: deserialize_conker_v1_StatusMessage,
+  },
+};
+
+exports.RobotControlClient = grpc.makeGenericClientConstructor(RobotControlService);

package/grpc/robot-control/conker_pb.d.ts

@@ -0,0 +1,168 @@
+// package: conker.v1
+// file: conker.proto
+
+import * as jspb from "google-protobuf";
+
+export class ConnectRequest extends jspb.Message {
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ConnectRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: ConnectRequest): ConnectRequest.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: ConnectRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ConnectRequest;
+  static deserializeBinaryFromReader(message: ConnectRequest, reader: jspb.BinaryReader): ConnectRequest;
+}
+
+export namespace ConnectRequest {
+  export type AsObject = {
+  }
+}
+
+export class ControlMessage extends jspb.Message {
+  getDestination(): string;
+  setDestination(value: string): void;
+
+  getPayload(): Uint8Array | string;
+  getPayload_asU8(): Uint8Array;
+  getPayload_asB64(): string;
+  setPayload(value: Uint8Array | string): void;
+
+  getTxid(): string;
+  setTxid(value: string): void;
+
+  getMetaMap(): jspb.Map<string, string>;
+  clearMetaMap(): void;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ControlMessage.AsObject;
+  static toObject(includeInstance: boolean, msg: ControlMessage): ControlMessage.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: ControlMessage, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ControlMessage;
+  static deserializeBinaryFromReader(message: ControlMessage, reader: jspb.BinaryReader): ControlMessage;
+}
+
+export namespace ControlMessage {
+  export type AsObject = {
+    destination: string,
+    payload: Uint8Array | string,
+    txid: string,
+    metaMap: Array<[string, string]>,
+  }
+}
+
+export class ControlEnd extends jspb.Message {
+  getCode(): number;
+  setCode(value: number): void;
+
+  getReason(): string;
+  setReason(value: string): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ControlEnd.AsObject;
+  static toObject(includeInstance: boolean, msg: ControlEnd): ControlEnd.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: ControlEnd, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ControlEnd;
+  static deserializeBinaryFromReader(message: ControlEnd, reader: jspb.BinaryReader): ControlEnd;
+}
+
+export namespace ControlEnd {
+  export type AsObject = {
+    code: number,
+    reason: string,
+  }
+}
+
+export class ControlAck extends jspb.Message {
+  getSuccess(): boolean;
+  setSuccess(value: boolean): void;
+
+  getStage(): string;
+  setStage(value: string): void;
+
+  getMessage(): string;
+  setMessage(value: string): void;
+
+  getTxid(): string;
+  setTxid(value: string): void;
+
+  getSeq(): number;
+  setSeq(value: number): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ControlAck.AsObject;
+  static toObject(includeInstance: boolean, msg: ControlAck): ControlAck.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: ControlAck, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ControlAck;
+  static deserializeBinaryFromReader(message: ControlAck, reader: jspb.BinaryReader): ControlAck;
+}
+
+export namespace ControlAck {
+  export type AsObject = {
+    success: boolean,
+    stage: string,
+    message: string,
+    txid: string,
+    seq: number,
+  }
+}
+
+export class ConnectAck extends jspb.Message {
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ConnectAck.AsObject;
+  static toObject(includeInstance: boolean, msg: ConnectAck): ConnectAck.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: ConnectAck, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ConnectAck;
+  static deserializeBinaryFromReader(message: ConnectAck, reader: jspb.BinaryReader): ConnectAck;
+}
+
+export namespace ConnectAck {
+  export type AsObject = {
+  }
+}
+
+export class StatusRequest extends jspb.Message {
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): StatusRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: StatusRequest): StatusRequest.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: StatusRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): StatusRequest;
+  static deserializeBinaryFromReader(message: StatusRequest, reader: jspb.BinaryReader): StatusRequest;
+}
+
+export namespace StatusRequest {
+  export type AsObject = {
+  }
+}
+
+export class StatusMessage extends jspb.Message {
+  clearConnectedrobotsList(): void;
+  getConnectedrobotsList(): Array<string>;
+  setConnectedrobotsList(value: Array<string>): void;
+  addConnectedrobots(value: string, index?: number): string;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): StatusMessage.AsObject;
+  static toObject(includeInstance: boolean, msg: StatusMessage): StatusMessage.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: StatusMessage, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): StatusMessage;
+  static deserializeBinaryFromReader(message: StatusMessage, reader: jspb.BinaryReader): StatusMessage;
+}
+
+export namespace StatusMessage {
+  export type AsObject = {
+    connectedrobotsList: Array<string>,
+  }
+}
+