@dronedeploy/rocos-js-sdk 0.0.1 → 2.6.1

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

@@ -0,0 +1,126 @@
+// package: conker.v1
+// file: conker.proto
+
+import * as conker_pb from "./conker_pb";
+import {grpc} from "@improbable-eng/grpc-web";
+
+type RobotControlConnectRobot = {
+  readonly methodName: string;
+  readonly service: typeof RobotControl;
+  readonly requestStream: false;
+  readonly responseStream: true;
+  readonly requestType: typeof conker_pb.ConnectRequest;
+  readonly responseType: typeof conker_pb.ControlMessage;
+};
+
+type RobotControlConnectRobotWithAckStream = {
+  readonly methodName: string;
+  readonly service: typeof RobotControl;
+  readonly requestStream: true;
+  readonly responseStream: true;
+  readonly requestType: typeof conker_pb.ControlAck;
+  readonly responseType: typeof conker_pb.ControlMessage;
+};
+
+type RobotControlControlRobot = {
+  readonly methodName: string;
+  readonly service: typeof RobotControl;
+  readonly requestStream: true;
+  readonly responseStream: false;
+  readonly requestType: typeof conker_pb.ControlMessage;
+  readonly responseType: typeof conker_pb.ControlEnd;
+};
+
+type RobotControlControlRobotCall = {
+  readonly methodName: string;
+  readonly service: typeof RobotControl;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof conker_pb.ControlMessage;
+  readonly responseType: typeof conker_pb.ControlAck;
+};
+
+type RobotControlControlRobotCallWithAckStream = {
+  readonly methodName: string;
+  readonly service: typeof RobotControl;
+  readonly requestStream: false;
+  readonly responseStream: true;
+  readonly requestType: typeof conker_pb.ControlMessage;
+  readonly responseType: typeof conker_pb.ControlAck;
+};
+
+type RobotControlStatus = {
+  readonly methodName: string;
+  readonly service: typeof RobotControl;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof conker_pb.StatusRequest;
+  readonly responseType: typeof conker_pb.StatusMessage;
+};
+
+export class RobotControl {
+  static readonly serviceName: string;
+  static readonly ConnectRobot: RobotControlConnectRobot;
+  static readonly ConnectRobotWithAckStream: RobotControlConnectRobotWithAckStream;
+  static readonly ControlRobot: RobotControlControlRobot;
+  static readonly ControlRobotCall: RobotControlControlRobotCall;
+  static readonly ControlRobotCallWithAckStream: RobotControlControlRobotCallWithAckStream;
+  static readonly Status: RobotControlStatus;
+}
+
+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 RobotControlClient {
+  readonly serviceHost: string;
+
+  constructor(serviceHost: string, options?: grpc.RpcOptions);
+  connectRobot(requestMessage: conker_pb.ConnectRequest, metadata?: grpc.Metadata): ResponseStream<conker_pb.ControlMessage>;
+  connectRobotWithAckStream(metadata?: grpc.Metadata): BidirectionalStream<conker_pb.ControlAck, conker_pb.ControlMessage>;
+  controlRobot(metadata?: grpc.Metadata): RequestStream<conker_pb.ControlMessage>;
+  controlRobotCall(
+    requestMessage: conker_pb.ControlMessage,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: conker_pb.ControlAck|null) => void
+  ): UnaryResponse;
+  controlRobotCall(
+    requestMessage: conker_pb.ControlMessage,
+    callback: (error: ServiceError|null, responseMessage: conker_pb.ControlAck|null) => void
+  ): UnaryResponse;
+  controlRobotCallWithAckStream(requestMessage: conker_pb.ControlMessage, metadata?: grpc.Metadata): ResponseStream<conker_pb.ControlAck>;
+  status(
+    requestMessage: conker_pb.StatusRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: conker_pb.StatusMessage|null) => void
+  ): UnaryResponse;
+  status(
+    requestMessage: conker_pb.StatusRequest,
+    callback: (error: ServiceError|null, responseMessage: conker_pb.StatusMessage|null) => void
+  ): UnaryResponse;
+}
+

package/grpc/robot-control/conker_pb_service.js

@@ -0,0 +1,301 @@
+// package: conker.v1
+// file: conker.proto
+
+var conker_pb = require("./conker_pb");
+var grpc = require("@improbable-eng/grpc-web").grpc;
+
+var RobotControl = (function () {
+  function RobotControl() {}
+  RobotControl.serviceName = "conker.v1.RobotControl";
+  return RobotControl;
+}());
+
+RobotControl.ConnectRobot = {
+  methodName: "ConnectRobot",
+  service: RobotControl,
+  requestStream: false,
+  responseStream: true,
+  requestType: conker_pb.ConnectRequest,
+  responseType: conker_pb.ControlMessage
+};
+
+RobotControl.ConnectRobotWithAckStream = {
+  methodName: "ConnectRobotWithAckStream",
+  service: RobotControl,
+  requestStream: true,
+  responseStream: true,
+  requestType: conker_pb.ControlAck,
+  responseType: conker_pb.ControlMessage
+};
+
+RobotControl.ControlRobot = {
+  methodName: "ControlRobot",
+  service: RobotControl,
+  requestStream: true,
+  responseStream: false,
+  requestType: conker_pb.ControlMessage,
+  responseType: conker_pb.ControlEnd
+};
+
+RobotControl.ControlRobotCall = {
+  methodName: "ControlRobotCall",
+  service: RobotControl,
+  requestStream: false,
+  responseStream: false,
+  requestType: conker_pb.ControlMessage,
+  responseType: conker_pb.ControlAck
+};
+
+RobotControl.ControlRobotCallWithAckStream = {
+  methodName: "ControlRobotCallWithAckStream",
+  service: RobotControl,
+  requestStream: false,
+  responseStream: true,
+  requestType: conker_pb.ControlMessage,
+  responseType: conker_pb.ControlAck
+};
+
+RobotControl.Status = {
+  methodName: "Status",
+  service: RobotControl,
+  requestStream: false,
+  responseStream: false,
+  requestType: conker_pb.StatusRequest,
+  responseType: conker_pb.StatusMessage
+};
+
+exports.RobotControl = RobotControl;
+
+function RobotControlClient(serviceHost, options) {
+  this.serviceHost = serviceHost;
+  this.options = options || {};
+}
+
+RobotControlClient.prototype.connectRobot = function connectRobot(requestMessage, metadata) {
+  var listeners = {
+    data: [],
+    end: [],
+    status: []
+  };
+  var client = grpc.invoke(RobotControl.ConnectRobot, {
+    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();
+    }
+  };
+};
+
+RobotControlClient.prototype.connectRobotWithAckStream = function connectRobotWithAckStream(metadata) {
+  var listeners = {
+    data: [],
+    end: [],
+    status: []
+  };
+  var client = grpc.client(RobotControl.ConnectRobotWithAckStream, {
+    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();
+    }
+  };
+};
+
+RobotControlClient.prototype.controlRobot = function controlRobot(metadata) {
+  var listeners = {
+    end: [],
+    status: []
+  };
+  var client = grpc.client(RobotControl.ControlRobot, {
+    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;
+  });
+  return {
+    on: function (type, handler) {
+      listeners[type].push(handler);
+      return this;
+    },
+    write: function (requestMessage) {
+      if (!client.started) {
+        client.start(metadata);
+      }
+      client.send(requestMessage);
+      return this;
+    },
+    end: function () {
+      client.finishSend();
+    },
+    cancel: function () {
+      listeners = null;
+      client.close();
+    }
+  };
+};
+
+RobotControlClient.prototype.controlRobotCall = function controlRobotCall(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(RobotControl.ControlRobotCall, {
+    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();
+    }
+  };
+};
+
+RobotControlClient.prototype.controlRobotCallWithAckStream = function controlRobotCallWithAckStream(requestMessage, metadata) {
+  var listeners = {
+    data: [],
+    end: [],
+    status: []
+  };
+  var client = grpc.invoke(RobotControl.ControlRobotCallWithAckStream, {
+    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();
+    }
+  };
+};
+
+RobotControlClient.prototype.status = function status(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(RobotControl.Status, {
+    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.RobotControlClient = RobotControlClient;
+

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

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

package/grpc/serviette/common.v1_grpc_pb.js

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

package/grpc/serviette/common.v1_pb.d.ts

@@ -0,0 +1,8 @@
+// package: 
+// file: common.v1.proto
+
+import * as jspb from "google-protobuf";
+import * as google_protobuf_descriptor_pb from "google-protobuf/google/protobuf/descriptor_pb";
+
+  export const required: jspb.ExtensionFieldInfo<boolean>;
+

package/grpc/serviette/common.v1_pb.js

@@ -0,0 +1,45 @@
+// source: common.v1.proto
+/**
+ * @fileoverview
+ * @enhanceable
+ * @suppress {messageConventions} JS Compiler reports an error if a variable or
+ *     field starts with 'MSG_' and isn't a translatable message.
+ * @public
+ */
+// GENERATED CODE -- DO NOT EDIT!
+/* eslint-disable */
+// @ts-nocheck
+
+var jspb = require('google-protobuf');
+var goog = jspb;
+var global = Function('return this')();
+
+var google_protobuf_descriptor_pb = require('google-protobuf/google/protobuf/descriptor_pb.js');
+goog.object.extend(proto, google_protobuf_descriptor_pb);
+goog.exportSymbol('proto.required', null, global);
+
+/**
+ * A tuple of {field number, class constructor} for the extension
+ * field named `required`.
+ * @type {!jspb.ExtensionFieldInfo<boolean>}
+ */
+proto.required = new jspb.ExtensionFieldInfo(
+    50002,
+    {required: 0},
+    null,
+     /** @type {?function((boolean|undefined),!jspb.Message=): !Object} */ (
+         null),
+    0);
+
+google_protobuf_descriptor_pb.FieldOptions.extensionsBinary[50002] = new jspb.ExtensionFieldBinaryInfo(
+    proto.required,
+    jspb.BinaryReader.prototype.readBool,
+    jspb.BinaryWriter.prototype.writeBool,
+    undefined,
+    undefined,
+    false);
+// This registers the extension field with the extended class, so that
+// toObject() will function correctly.
+google_protobuf_descriptor_pb.FieldOptions.extensions[50002] = proto.required;
+
+goog.object.extend(exports, proto);

package/grpc/serviette/common.v1_pb_service.d.ts

@@ -0,0 +1,3 @@
+// package: 
+// file: common.v1.proto
+

package/grpc/serviette/common.v1_pb_service.js

@@ -0,0 +1,3 @@
+// package: 
+// file: common.v1.proto
+

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

@@ -0,0 +1,137 @@
+// GENERATED CODE -- DO NOT EDIT!
+
+// package: serviette.v1
+// file: serviette.v1.proto
+
+import * as serviette_v1_pb from "./serviette.v1_pb";
+import * as google_protobuf_empty_pb from "google-protobuf/google/protobuf/empty_pb";
+import * as grpc from "@grpc/grpc-js";
+
+interface IServiceReceiverService extends grpc.ServiceDefinition<grpc.UntypedServiceImplementation> {
+  registerReceiver: grpc.MethodDefinition<serviette_v1_pb.ResponseChannelMessage, serviette_v1_pb.RequestChannelMessage>;
+}
+
+export const ServiceReceiverService: IServiceReceiverService;
+
+export interface IServiceReceiverServer extends grpc.UntypedServiceImplementation {
+  registerReceiver: grpc.handleBidiStreamingCall<serviette_v1_pb.ResponseChannelMessage, serviette_v1_pb.RequestChannelMessage>;
+}
+
+export class ServiceReceiverClient extends grpc.Client {
+  constructor(address: string, credentials: grpc.ChannelCredentials, options?: object);
+  registerReceiver(metadataOrOptions?: grpc.Metadata | grpc.CallOptions | null): grpc.ClientDuplexStream<serviette_v1_pb.ResponseChannelMessage, serviette_v1_pb.RequestChannelMessage>;
+  registerReceiver(metadata?: grpc.Metadata | null, options?: grpc.CallOptions | null): grpc.ClientDuplexStream<serviette_v1_pb.ResponseChannelMessage, serviette_v1_pb.RequestChannelMessage>;
+}
+
+interface IServiceCallerService extends grpc.ServiceDefinition<grpc.UntypedServiceImplementation> {
+  callServices: grpc.MethodDefinition<serviette_v1_pb.RequestChannelMessage, serviette_v1_pb.ResponseChannelMessage>;
+  listKnownReceivers: grpc.MethodDefinition<google_protobuf_empty_pb.Empty, serviette_v1_pb.ReceiverRecords>;
+}
+
+export const ServiceCallerService: IServiceCallerService;
+
+export interface IServiceCallerServer extends grpc.UntypedServiceImplementation {
+  callServices: grpc.handleBidiStreamingCall<serviette_v1_pb.RequestChannelMessage, serviette_v1_pb.ResponseChannelMessage>;
+  listKnownReceivers: grpc.handleUnaryCall<google_protobuf_empty_pb.Empty, serviette_v1_pb.ReceiverRecords>;
+}
+
+export class ServiceCallerClient extends grpc.Client {
+  constructor(address: string, credentials: grpc.ChannelCredentials, options?: object);
+  callServices(metadataOrOptions?: grpc.Metadata | grpc.CallOptions | null): grpc.ClientDuplexStream<serviette_v1_pb.RequestChannelMessage, serviette_v1_pb.ResponseChannelMessage>;
+  callServices(metadata?: grpc.Metadata | null, options?: grpc.CallOptions | null): grpc.ClientDuplexStream<serviette_v1_pb.RequestChannelMessage, serviette_v1_pb.ResponseChannelMessage>;
+  listKnownReceivers(argument: google_protobuf_empty_pb.Empty, callback: grpc.requestCallback<serviette_v1_pb.ReceiverRecords>): grpc.ClientUnaryCall;
+  listKnownReceivers(argument: google_protobuf_empty_pb.Empty, metadataOrOptions: grpc.Metadata | grpc.CallOptions | null, callback: grpc.requestCallback<serviette_v1_pb.ReceiverRecords>): grpc.ClientUnaryCall;
+  listKnownReceivers(argument: google_protobuf_empty_pb.Empty, metadata: grpc.Metadata | null, options: grpc.CallOptions | null, callback: grpc.requestCallback<serviette_v1_pb.ReceiverRecords>): grpc.ClientUnaryCall;
+}
+
+interface IWebServiceReceiverService extends grpc.ServiceDefinition<grpc.UntypedServiceImplementation> {
+  registerReceiver: grpc.MethodDefinition<serviette_v1_pb.WebReceiverRegistration, serviette_v1_pb.RequestChannelMessage>;
+  sendResponse: grpc.MethodDefinition<serviette_v1_pb.ResponseChannelMessage, serviette_v1_pb.WebSendResponseMessage>;
+}
+
+export const WebServiceReceiverService: IWebServiceReceiverService;
+
+export interface IWebServiceReceiverServer extends grpc.UntypedServiceImplementation {
+  registerReceiver: grpc.handleServerStreamingCall<serviette_v1_pb.WebReceiverRegistration, serviette_v1_pb.RequestChannelMessage>;
+  sendResponse: grpc.handleUnaryCall<serviette_v1_pb.ResponseChannelMessage, serviette_v1_pb.WebSendResponseMessage>;
+}
+
+export class WebServiceReceiverClient extends grpc.Client {
+  constructor(address: string, credentials: grpc.ChannelCredentials, options?: object);
+  registerReceiver(argument: serviette_v1_pb.WebReceiverRegistration, metadataOrOptions?: grpc.Metadata | grpc.CallOptions | null): grpc.ClientReadableStream<serviette_v1_pb.RequestChannelMessage>;
+  registerReceiver(argument: serviette_v1_pb.WebReceiverRegistration, metadata?: grpc.Metadata | null, options?: grpc.CallOptions | null): grpc.ClientReadableStream<serviette_v1_pb.RequestChannelMessage>;
+  sendResponse(argument: serviette_v1_pb.ResponseChannelMessage, callback: grpc.requestCallback<serviette_v1_pb.WebSendResponseMessage>): grpc.ClientUnaryCall;
+  sendResponse(argument: serviette_v1_pb.ResponseChannelMessage, metadataOrOptions: grpc.Metadata | grpc.CallOptions | null, callback: grpc.requestCallback<serviette_v1_pb.WebSendResponseMessage>): grpc.ClientUnaryCall;
+  sendResponse(argument: serviette_v1_pb.ResponseChannelMessage, metadata: grpc.Metadata | null, options: grpc.CallOptions | null, callback: grpc.requestCallback<serviette_v1_pb.WebSendResponseMessage>): grpc.ClientUnaryCall;
+}
+
+interface IWebServiceCallerService extends grpc.ServiceDefinition<grpc.UntypedServiceImplementation> {
+  callService: grpc.MethodDefinition<serviette_v1_pb.ServiceRequest, serviette_v1_pb.ResponseChannelMessage>;
+  callServices: grpc.MethodDefinition<serviette_v1_pb.ServiceRequests, serviette_v1_pb.ResponseChannelMessage>;
+  cancelService: grpc.MethodDefinition<serviette_v1_pb.RequestCancellation, serviette_v1_pb.ResponseChannelMessage>;
+  cancelServices: grpc.MethodDefinition<serviette_v1_pb.RequestCancellations, serviette_v1_pb.ResponseChannelMessage>;
+  listKnownReceivers: grpc.MethodDefinition<google_protobuf_empty_pb.Empty, serviette_v1_pb.ReceiverRecords>;
+}
+
+export const WebServiceCallerService: IWebServiceCallerService;
+
+export interface IWebServiceCallerServer extends grpc.UntypedServiceImplementation {
+  callService: grpc.handleServerStreamingCall<serviette_v1_pb.ServiceRequest, serviette_v1_pb.ResponseChannelMessage>;
+  callServices: grpc.handleServerStreamingCall<serviette_v1_pb.ServiceRequests, serviette_v1_pb.ResponseChannelMessage>;
+  cancelService: grpc.handleServerStreamingCall<serviette_v1_pb.RequestCancellation, serviette_v1_pb.ResponseChannelMessage>;
+  cancelServices: grpc.handleServerStreamingCall<serviette_v1_pb.RequestCancellations, serviette_v1_pb.ResponseChannelMessage>;
+  listKnownReceivers: grpc.handleUnaryCall<google_protobuf_empty_pb.Empty, serviette_v1_pb.ReceiverRecords>;
+}
+
+export class WebServiceCallerClient extends grpc.Client {
+  constructor(address: string, credentials: grpc.ChannelCredentials, options?: object);
+  callService(argument: serviette_v1_pb.ServiceRequest, metadataOrOptions?: grpc.Metadata | grpc.CallOptions | null): grpc.ClientReadableStream<serviette_v1_pb.ResponseChannelMessage>;
+  callService(argument: serviette_v1_pb.ServiceRequest, metadata?: grpc.Metadata | null, options?: grpc.CallOptions | null): grpc.ClientReadableStream<serviette_v1_pb.ResponseChannelMessage>;
+  callServices(argument: serviette_v1_pb.ServiceRequests, metadataOrOptions?: grpc.Metadata | grpc.CallOptions | null): grpc.ClientReadableStream<serviette_v1_pb.ResponseChannelMessage>;
+  callServices(argument: serviette_v1_pb.ServiceRequests, metadata?: grpc.Metadata | null, options?: grpc.CallOptions | null): grpc.ClientReadableStream<serviette_v1_pb.ResponseChannelMessage>;
+  cancelService(argument: serviette_v1_pb.RequestCancellation, metadataOrOptions?: grpc.Metadata | grpc.CallOptions | null): grpc.ClientReadableStream<serviette_v1_pb.ResponseChannelMessage>;
+  cancelService(argument: serviette_v1_pb.RequestCancellation, metadata?: grpc.Metadata | null, options?: grpc.CallOptions | null): grpc.ClientReadableStream<serviette_v1_pb.ResponseChannelMessage>;
+  cancelServices(argument: serviette_v1_pb.RequestCancellations, metadataOrOptions?: grpc.Metadata | grpc.CallOptions | null): grpc.ClientReadableStream<serviette_v1_pb.ResponseChannelMessage>;
+  cancelServices(argument: serviette_v1_pb.RequestCancellations, metadata?: grpc.Metadata | null, options?: grpc.CallOptions | null): grpc.ClientReadableStream<serviette_v1_pb.ResponseChannelMessage>;
+  listKnownReceivers(argument: google_protobuf_empty_pb.Empty, callback: grpc.requestCallback<serviette_v1_pb.ReceiverRecords>): grpc.ClientUnaryCall;
+  listKnownReceivers(argument: google_protobuf_empty_pb.Empty, metadataOrOptions: grpc.Metadata | grpc.CallOptions | null, callback: grpc.requestCallback<serviette_v1_pb.ReceiverRecords>): grpc.ClientUnaryCall;
+  listKnownReceivers(argument: google_protobuf_empty_pb.Empty, metadata: grpc.Metadata | null, options: grpc.CallOptions | null, callback: grpc.requestCallback<serviette_v1_pb.ReceiverRecords>): grpc.ClientUnaryCall;
+}
+
+interface IMeshAdminService extends grpc.ServiceDefinition<grpc.UntypedServiceImplementation> {
+  listKnownReceivers: grpc.MethodDefinition<google_protobuf_empty_pb.Empty, serviette_v1_pb.ReceiverRecords>;
+  addGatewayNode: grpc.MethodDefinition<serviette_v1_pb.MeshNodeRequest, serviette_v1_pb.MeshNodeResponse>;
+}
+
+export const MeshAdminService: IMeshAdminService;
+
+export interface IMeshAdminServer extends grpc.UntypedServiceImplementation {
+  listKnownReceivers: grpc.handleUnaryCall<google_protobuf_empty_pb.Empty, serviette_v1_pb.ReceiverRecords>;
+  addGatewayNode: grpc.handleUnaryCall<serviette_v1_pb.MeshNodeRequest, serviette_v1_pb.MeshNodeResponse>;
+}
+
+export class MeshAdminClient extends grpc.Client {
+  constructor(address: string, credentials: grpc.ChannelCredentials, options?: object);
+  listKnownReceivers(argument: google_protobuf_empty_pb.Empty, callback: grpc.requestCallback<serviette_v1_pb.ReceiverRecords>): grpc.ClientUnaryCall;
+  listKnownReceivers(argument: google_protobuf_empty_pb.Empty, metadataOrOptions: grpc.Metadata | grpc.CallOptions | null, callback: grpc.requestCallback<serviette_v1_pb.ReceiverRecords>): grpc.ClientUnaryCall;
+  listKnownReceivers(argument: google_protobuf_empty_pb.Empty, metadata: grpc.Metadata | null, options: grpc.CallOptions | null, callback: grpc.requestCallback<serviette_v1_pb.ReceiverRecords>): grpc.ClientUnaryCall;
+  addGatewayNode(argument: serviette_v1_pb.MeshNodeRequest, callback: grpc.requestCallback<serviette_v1_pb.MeshNodeResponse>): grpc.ClientUnaryCall;
+  addGatewayNode(argument: serviette_v1_pb.MeshNodeRequest, metadataOrOptions: grpc.Metadata | grpc.CallOptions | null, callback: grpc.requestCallback<serviette_v1_pb.MeshNodeResponse>): grpc.ClientUnaryCall;
+  addGatewayNode(argument: serviette_v1_pb.MeshNodeRequest, metadata: grpc.Metadata | null, options: grpc.CallOptions | null, callback: grpc.requestCallback<serviette_v1_pb.MeshNodeResponse>): grpc.ClientUnaryCall;
+}
+
+interface IMeshService extends grpc.ServiceDefinition<grpc.UntypedServiceImplementation> {
+  joinMesh: grpc.MethodDefinition<serviette_v1_pb.MeshInfo, serviette_v1_pb.MeshInfo>;
+}
+
+export const MeshService: IMeshService;
+
+export interface IMeshServer extends grpc.UntypedServiceImplementation {
+  joinMesh: grpc.handleBidiStreamingCall<serviette_v1_pb.MeshInfo, serviette_v1_pb.MeshInfo>;
+}
+
+export class MeshClient extends grpc.Client {
+  constructor(address: string, credentials: grpc.ChannelCredentials, options?: object);
+  joinMesh(metadataOrOptions?: grpc.Metadata | grpc.CallOptions | null): grpc.ClientDuplexStream<serviette_v1_pb.MeshInfo, serviette_v1_pb.MeshInfo>;
+  joinMesh(metadata?: grpc.Metadata | null, options?: grpc.CallOptions | null): grpc.ClientDuplexStream<serviette_v1_pb.MeshInfo, serviette_v1_pb.MeshInfo>;
+}