@dronedeploy/rocos-js-sdk 0.0.1 → 2.6.1

package/grpc/serviette/serviette.v1_pb_service.js

@@ -0,0 +1,699 @@
+// package: serviette.v1
+// file: serviette.v1.proto
+
+var serviette_v1_pb = require("./serviette.v1_pb");
+var google_protobuf_empty_pb = require("google-protobuf/google/protobuf/empty_pb");
+var grpc = require("@improbable-eng/grpc-web").grpc;
+
+var ServiceReceiver = (function () {
+  function ServiceReceiver() {}
+  ServiceReceiver.serviceName = "serviette.v1.ServiceReceiver";
+  return ServiceReceiver;
+}());
+
+ServiceReceiver.RegisterReceiver = {
+  methodName: "RegisterReceiver",
+  service: ServiceReceiver,
+  requestStream: true,
+  responseStream: true,
+  requestType: serviette_v1_pb.ResponseChannelMessage,
+  responseType: serviette_v1_pb.RequestChannelMessage
+};
+
+exports.ServiceReceiver = ServiceReceiver;
+
+function ServiceReceiverClient(serviceHost, options) {
+  this.serviceHost = serviceHost;
+  this.options = options || {};
+}
+
+ServiceReceiverClient.prototype.registerReceiver = function registerReceiver(metadata) {
+  var listeners = {
+    data: [],
+    end: [],
+    status: []
+  };
+  var client = grpc.client(ServiceReceiver.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.ServiceReceiverClient = ServiceReceiverClient;
+
+var ServiceCaller = (function () {
+  function ServiceCaller() {}
+  ServiceCaller.serviceName = "serviette.v1.ServiceCaller";
+  return ServiceCaller;
+}());
+
+ServiceCaller.CallServices = {
+  methodName: "CallServices",
+  service: ServiceCaller,
+  requestStream: true,
+  responseStream: true,
+  requestType: serviette_v1_pb.RequestChannelMessage,
+  responseType: serviette_v1_pb.ResponseChannelMessage
+};
+
+ServiceCaller.ListKnownReceivers = {
+  methodName: "ListKnownReceivers",
+  service: ServiceCaller,
+  requestStream: false,
+  responseStream: false,
+  requestType: google_protobuf_empty_pb.Empty,
+  responseType: serviette_v1_pb.ReceiverRecords
+};
+
+exports.ServiceCaller = ServiceCaller;
+
+function ServiceCallerClient(serviceHost, options) {
+  this.serviceHost = serviceHost;
+  this.options = options || {};
+}
+
+ServiceCallerClient.prototype.callServices = function callServices(metadata) {
+  var listeners = {
+    data: [],
+    end: [],
+    status: []
+  };
+  var client = grpc.client(ServiceCaller.CallServices, {
+    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();
+    }
+  };
+};
+
+ServiceCallerClient.prototype.listKnownReceivers = function listKnownReceivers(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(ServiceCaller.ListKnownReceivers, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+exports.ServiceCallerClient = ServiceCallerClient;
+
+var WebServiceReceiver = (function () {
+  function WebServiceReceiver() {}
+  WebServiceReceiver.serviceName = "serviette.v1.WebServiceReceiver";
+  return WebServiceReceiver;
+}());
+
+WebServiceReceiver.RegisterReceiver = {
+  methodName: "RegisterReceiver",
+  service: WebServiceReceiver,
+  requestStream: false,
+  responseStream: true,
+  requestType: serviette_v1_pb.WebReceiverRegistration,
+  responseType: serviette_v1_pb.RequestChannelMessage
+};
+
+WebServiceReceiver.SendResponse = {
+  methodName: "SendResponse",
+  service: WebServiceReceiver,
+  requestStream: false,
+  responseStream: false,
+  requestType: serviette_v1_pb.ResponseChannelMessage,
+  responseType: serviette_v1_pb.WebSendResponseMessage
+};
+
+exports.WebServiceReceiver = WebServiceReceiver;
+
+function WebServiceReceiverClient(serviceHost, options) {
+  this.serviceHost = serviceHost;
+  this.options = options || {};
+}
+
+WebServiceReceiverClient.prototype.registerReceiver = function registerReceiver(requestMessage, metadata) {
+  var listeners = {
+    data: [],
+    end: [],
+    status: []
+  };
+  var client = grpc.invoke(WebServiceReceiver.RegisterReceiver, {
+    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();
+    }
+  };
+};
+
+WebServiceReceiverClient.prototype.sendResponse = function sendResponse(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(WebServiceReceiver.SendResponse, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+exports.WebServiceReceiverClient = WebServiceReceiverClient;
+
+var WebServiceCaller = (function () {
+  function WebServiceCaller() {}
+  WebServiceCaller.serviceName = "serviette.v1.WebServiceCaller";
+  return WebServiceCaller;
+}());
+
+WebServiceCaller.CallService = {
+  methodName: "CallService",
+  service: WebServiceCaller,
+  requestStream: false,
+  responseStream: true,
+  requestType: serviette_v1_pb.ServiceRequest,
+  responseType: serviette_v1_pb.ResponseChannelMessage
+};
+
+WebServiceCaller.CallServices = {
+  methodName: "CallServices",
+  service: WebServiceCaller,
+  requestStream: false,
+  responseStream: true,
+  requestType: serviette_v1_pb.ServiceRequests,
+  responseType: serviette_v1_pb.ResponseChannelMessage
+};
+
+WebServiceCaller.CancelService = {
+  methodName: "CancelService",
+  service: WebServiceCaller,
+  requestStream: false,
+  responseStream: true,
+  requestType: serviette_v1_pb.RequestCancellation,
+  responseType: serviette_v1_pb.ResponseChannelMessage
+};
+
+WebServiceCaller.CancelServices = {
+  methodName: "CancelServices",
+  service: WebServiceCaller,
+  requestStream: false,
+  responseStream: true,
+  requestType: serviette_v1_pb.RequestCancellations,
+  responseType: serviette_v1_pb.ResponseChannelMessage
+};
+
+WebServiceCaller.ListKnownReceivers = {
+  methodName: "ListKnownReceivers",
+  service: WebServiceCaller,
+  requestStream: false,
+  responseStream: false,
+  requestType: google_protobuf_empty_pb.Empty,
+  responseType: serviette_v1_pb.ReceiverRecords
+};
+
+exports.WebServiceCaller = WebServiceCaller;
+
+function WebServiceCallerClient(serviceHost, options) {
+  this.serviceHost = serviceHost;
+  this.options = options || {};
+}
+
+WebServiceCallerClient.prototype.callService = function callService(requestMessage, metadata) {
+  var listeners = {
+    data: [],
+    end: [],
+    status: []
+  };
+  var client = grpc.invoke(WebServiceCaller.CallService, {
+    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();
+    }
+  };
+};
+
+WebServiceCallerClient.prototype.callServices = function callServices(requestMessage, metadata) {
+  var listeners = {
+    data: [],
+    end: [],
+    status: []
+  };
+  var client = grpc.invoke(WebServiceCaller.CallServices, {
+    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();
+    }
+  };
+};
+
+WebServiceCallerClient.prototype.cancelService = function cancelService(requestMessage, metadata) {
+  var listeners = {
+    data: [],
+    end: [],
+    status: []
+  };
+  var client = grpc.invoke(WebServiceCaller.CancelService, {
+    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();
+    }
+  };
+};
+
+WebServiceCallerClient.prototype.cancelServices = function cancelServices(requestMessage, metadata) {
+  var listeners = {
+    data: [],
+    end: [],
+    status: []
+  };
+  var client = grpc.invoke(WebServiceCaller.CancelServices, {
+    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();
+    }
+  };
+};
+
+WebServiceCallerClient.prototype.listKnownReceivers = function listKnownReceivers(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(WebServiceCaller.ListKnownReceivers, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+exports.WebServiceCallerClient = WebServiceCallerClient;
+
+var MeshAdmin = (function () {
+  function MeshAdmin() {}
+  MeshAdmin.serviceName = "serviette.v1.MeshAdmin";
+  return MeshAdmin;
+}());
+
+MeshAdmin.ListKnownReceivers = {
+  methodName: "ListKnownReceivers",
+  service: MeshAdmin,
+  requestStream: false,
+  responseStream: false,
+  requestType: google_protobuf_empty_pb.Empty,
+  responseType: serviette_v1_pb.ReceiverRecords
+};
+
+MeshAdmin.AddGatewayNode = {
+  methodName: "AddGatewayNode",
+  service: MeshAdmin,
+  requestStream: false,
+  responseStream: false,
+  requestType: serviette_v1_pb.MeshNodeRequest,
+  responseType: serviette_v1_pb.MeshNodeResponse
+};
+
+exports.MeshAdmin = MeshAdmin;
+
+function MeshAdminClient(serviceHost, options) {
+  this.serviceHost = serviceHost;
+  this.options = options || {};
+}
+
+MeshAdminClient.prototype.listKnownReceivers = function listKnownReceivers(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(MeshAdmin.ListKnownReceivers, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+MeshAdminClient.prototype.addGatewayNode = function addGatewayNode(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(MeshAdmin.AddGatewayNode, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+exports.MeshAdminClient = MeshAdminClient;
+
+var Mesh = (function () {
+  function Mesh() {}
+  Mesh.serviceName = "serviette.v1.Mesh";
+  return Mesh;
+}());
+
+Mesh.JoinMesh = {
+  methodName: "JoinMesh",
+  service: Mesh,
+  requestStream: true,
+  responseStream: true,
+  requestType: serviette_v1_pb.MeshInfo,
+  responseType: serviette_v1_pb.MeshInfo
+};
+
+exports.Mesh = Mesh;
+
+function MeshClient(serviceHost, options) {
+  this.serviceHost = serviceHost;
+  this.options = options || {};
+}
+
+MeshClient.prototype.joinMesh = function joinMesh(metadata) {
+  var listeners = {
+    data: [],
+    end: [],
+    status: []
+  };
+  var client = grpc.client(Mesh.JoinMesh, {
+    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.MeshClient = MeshClient;
+

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

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

package/grpc/serviette/uri.v1_grpc_pb.js

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