@dronedeploy/rocos-js-sdk 0.0.1 → 2.6.1

package/grpc/rambo/rambo.v1_pb_service.d.ts

@@ -0,0 +1,76 @@
+// package: rambo.v1
+// file: rambo.v1.proto
+
+import * as rambo_v1_pb from "./rambo.v1_pb";
+import {grpc} from "@improbable-eng/grpc-web";
+
+type CommandReceiverRegisterReceiver = {
+  readonly methodName: string;
+  readonly service: typeof CommandReceiver;
+  readonly requestStream: true;
+  readonly responseStream: true;
+  readonly requestType: typeof rambo_v1_pb.ResponseChannelMessage;
+  readonly responseType: typeof rambo_v1_pb.RequestChannelMessage;
+};
+
+export class CommandReceiver {
+  static readonly serviceName: string;
+  static readonly RegisterReceiver: CommandReceiverRegisterReceiver;
+}
+
+type CommandCallCommand = {
+  readonly methodName: string;
+  readonly service: typeof Command;
+  readonly requestStream: false;
+  readonly responseStream: true;
+  readonly requestType: typeof rambo_v1_pb.CommandRequest;
+  readonly responseType: typeof rambo_v1_pb.ResponseChannelMessage;
+};
+
+export class Command {
+  static readonly serviceName: string;
+  static readonly CallCommand: CommandCallCommand;
+}
+
+export type ServiceError = { message: string, code: number; metadata: grpc.Metadata }
+export type Status = { details: string, code: number; metadata: grpc.Metadata }
+
+interface UnaryResponse {
+  cancel(): void;
+}
+interface ResponseStream<T> {
+  cancel(): void;
+  on(type: 'data', handler: (message: T) => void): ResponseStream<T>;
+  on(type: 'end', handler: (status?: Status) => void): ResponseStream<T>;
+  on(type: 'status', handler: (status: Status) => void): ResponseStream<T>;
+}
+interface RequestStream<T> {
+  write(message: T): RequestStream<T>;
+  end(): void;
+  cancel(): void;
+  on(type: 'end', handler: (status?: Status) => void): RequestStream<T>;
+  on(type: 'status', handler: (status: Status) => void): RequestStream<T>;
+}
+interface BidirectionalStream<ReqT, ResT> {
+  write(message: ReqT): BidirectionalStream<ReqT, ResT>;
+  end(): void;
+  cancel(): void;
+  on(type: 'data', handler: (message: ResT) => void): BidirectionalStream<ReqT, ResT>;
+  on(type: 'end', handler: (status?: Status) => void): BidirectionalStream<ReqT, ResT>;
+  on(type: 'status', handler: (status: Status) => void): BidirectionalStream<ReqT, ResT>;
+}
+
+export class CommandReceiverClient {
+  readonly serviceHost: string;
+
+  constructor(serviceHost: string, options?: grpc.RpcOptions);
+  registerReceiver(metadata?: grpc.Metadata): BidirectionalStream<rambo_v1_pb.ResponseChannelMessage, rambo_v1_pb.RequestChannelMessage>;
+}
+
+export class CommandClient {
+  readonly serviceHost: string;
+
+  constructor(serviceHost: string, options?: grpc.RpcOptions);
+  callCommand(requestMessage: rambo_v1_pb.CommandRequest, metadata?: grpc.Metadata): ResponseStream<rambo_v1_pb.ResponseChannelMessage>;
+}
+

package/grpc/rambo/rambo.v1_pb_service.js

@@ -0,0 +1,138 @@
+// package: rambo.v1
+// file: rambo.v1.proto
+
+var rambo_v1_pb = require("./rambo.v1_pb");
+var grpc = require("@improbable-eng/grpc-web").grpc;
+
+var CommandReceiver = (function () {
+  function CommandReceiver() {}
+  CommandReceiver.serviceName = "rambo.v1.CommandReceiver";
+  return CommandReceiver;
+}());
+
+CommandReceiver.RegisterReceiver = {
+  methodName: "RegisterReceiver",
+  service: CommandReceiver,
+  requestStream: true,
+  responseStream: true,
+  requestType: rambo_v1_pb.ResponseChannelMessage,
+  responseType: rambo_v1_pb.RequestChannelMessage
+};
+
+exports.CommandReceiver = CommandReceiver;
+
+function CommandReceiverClient(serviceHost, options) {
+  this.serviceHost = serviceHost;
+  this.options = options || {};
+}
+
+CommandReceiverClient.prototype.registerReceiver = function registerReceiver(metadata) {
+  var listeners = {
+    data: [],
+    end: [],
+    status: []
+  };
+  var client = grpc.client(CommandReceiver.RegisterReceiver, {
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport
+  });
+  client.onEnd(function (status, statusMessage, trailers) {
+    listeners.status.forEach(function (handler) {
+      handler({ code: status, details: statusMessage, metadata: trailers });
+    });
+    listeners.end.forEach(function (handler) {
+      handler({ code: status, details: statusMessage, metadata: trailers });
+    });
+    listeners = null;
+  });
+  client.onMessage(function (message) {
+    listeners.data.forEach(function (handler) {
+      handler(message);
+    })
+  });
+  client.start(metadata);
+  return {
+    on: function (type, handler) {
+      listeners[type].push(handler);
+      return this;
+    },
+    write: function (requestMessage) {
+      client.send(requestMessage);
+      return this;
+    },
+    end: function () {
+      client.finishSend();
+    },
+    cancel: function () {
+      listeners = null;
+      client.close();
+    }
+  };
+};
+
+exports.CommandReceiverClient = CommandReceiverClient;
+
+var Command = (function () {
+  function Command() {}
+  Command.serviceName = "rambo.v1.Command";
+  return Command;
+}());
+
+Command.CallCommand = {
+  methodName: "CallCommand",
+  service: Command,
+  requestStream: false,
+  responseStream: true,
+  requestType: rambo_v1_pb.CommandRequest,
+  responseType: rambo_v1_pb.ResponseChannelMessage
+};
+
+exports.Command = Command;
+
+function CommandClient(serviceHost, options) {
+  this.serviceHost = serviceHost;
+  this.options = options || {};
+}
+
+CommandClient.prototype.callCommand = function callCommand(requestMessage, metadata) {
+  var listeners = {
+    data: [],
+    end: [],
+    status: []
+  };
+  var client = grpc.invoke(Command.CallCommand, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onMessage: function (responseMessage) {
+      listeners.data.forEach(function (handler) {
+        handler(responseMessage);
+      });
+    },
+    onEnd: function (status, statusMessage, trailers) {
+      listeners.status.forEach(function (handler) {
+        handler({ code: status, details: statusMessage, metadata: trailers });
+      });
+      listeners.end.forEach(function (handler) {
+        handler({ code: status, details: statusMessage, metadata: trailers });
+      });
+      listeners = null;
+    }
+  });
+  return {
+    on: function (type, handler) {
+      listeners[type].push(handler);
+      return this;
+    },
+    cancel: function () {
+      listeners = null;
+      client.close();
+    }
+  };
+};
+
+exports.CommandClient = CommandClient;
+

package/grpc/rambo/uri.v1_grpc_pb.d.ts

@@ -0,0 +1 @@
+// GENERATED CODE -- NO SERVICES IN PROTO

package/grpc/rambo/uri.v1_grpc_pb.js

@@ -0,0 +1 @@
+// GENERATED CODE -- NO SERVICES IN PROTO

package/grpc/rambo/uri.v1_pb.d.ts

@@ -0,0 +1,80 @@
+// package: rambo.v1
+// file: uri.v1.proto
+
+import * as jspb from "google-protobuf";
+
+export class RocosUri extends jspb.Message {
+  getScheme(): RocosUriSchemeMap[keyof RocosUriSchemeMap];
+  setScheme(value: RocosUriSchemeMap[keyof RocosUriSchemeMap]): void;
+
+  getAuthority(): string;
+  setAuthority(value: string): void;
+
+  hasPath(): boolean;
+  clearPath(): void;
+  getPath(): RocosUriPath | undefined;
+  setPath(value?: RocosUriPath): void;
+
+  getQueryMap(): jspb.Map<string, string>;
+  clearQueryMap(): void;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): RocosUri.AsObject;
+  static toObject(includeInstance: boolean, msg: RocosUri): RocosUri.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: RocosUri, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): RocosUri;
+  static deserializeBinaryFromReader(message: RocosUri, reader: jspb.BinaryReader): RocosUri;
+}
+
+export namespace RocosUri {
+  export type AsObject = {
+    scheme: RocosUriSchemeMap[keyof RocosUriSchemeMap],
+    authority: string,
+    path?: RocosUriPath.AsObject,
+    queryMap: Array<[string, string]>,
+  }
+}
+
+export class RocosUriPath extends jspb.Message {
+  getProject(): string;
+  setProject(value: string): void;
+
+  getCallsign(): string;
+  setCallsign(value: string): void;
+
+  getSubsystem(): string;
+  setSubsystem(value: string): void;
+
+  getComponent(): string;
+  setComponent(value: string): void;
+
+  getTopic(): string;
+  setTopic(value: string): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): RocosUriPath.AsObject;
+  static toObject(includeInstance: boolean, msg: RocosUriPath): RocosUriPath.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: RocosUriPath, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): RocosUriPath;
+  static deserializeBinaryFromReader(message: RocosUriPath, reader: jspb.BinaryReader): RocosUriPath;
+}
+
+export namespace RocosUriPath {
+  export type AsObject = {
+    project: string,
+    callsign: string,
+    subsystem: string,
+    component: string,
+    topic: string,
+  }
+}
+
+export interface RocosUriSchemeMap {
+  GRPC: 0;
+}
+
+export const RocosUriScheme: RocosUriSchemeMap;
+