@dronedeploy/rocos-js-sdk 0.0.1 → 2.6.1

package/grpc/teletubby/teletubby_pb_service.d.ts

@@ -0,0 +1,193 @@
+// package: teletubby.v1
+// file: teletubby.proto
+
+import * as teletubby_pb from "./teletubby_pb";
+import {grpc} from "@improbable-eng/grpc-web";
+
+type TelemetryReceiverRegisterStreamReceiver = {
+  readonly methodName: string;
+  readonly service: typeof TelemetryReceiver;
+  readonly requestStream: true;
+  readonly responseStream: true;
+  readonly requestType: typeof teletubby_pb.ReceiverStreamMessage;
+  readonly responseType: typeof teletubby_pb.TelemetryStreamMessage;
+};
+
+type TelemetryReceiverRequestTelemetry = {
+  readonly methodName: string;
+  readonly service: typeof TelemetryReceiver;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof teletubby_pb.TelemetryRequest;
+  readonly responseType: typeof teletubby_pb.TelemetryRequestAck;
+};
+
+type TelemetryReceiverRequestTelemetryQuery = {
+  readonly methodName: string;
+  readonly service: typeof TelemetryReceiver;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof teletubby_pb.TelemetryQueryRequest;
+  readonly responseType: typeof teletubby_pb.TelemetryRequestAck;
+};
+
+export class TelemetryReceiver {
+  static readonly serviceName: string;
+  static readonly RegisterStreamReceiver: TelemetryReceiverRegisterStreamReceiver;
+  static readonly RequestTelemetry: TelemetryReceiverRequestTelemetry;
+  static readonly RequestTelemetryQuery: TelemetryReceiverRequestTelemetryQuery;
+}
+
+type TelemetryGatewayRegisterSender = {
+  readonly methodName: string;
+  readonly service: typeof TelemetryGateway;
+  readonly requestStream: false;
+  readonly responseStream: true;
+  readonly requestType: typeof teletubby_pb.RegistrationMessage;
+  readonly responseType: typeof teletubby_pb.ConfigMessage;
+};
+
+type TelemetryGatewayRegisterReceiver = {
+  readonly methodName: string;
+  readonly service: typeof TelemetryGateway;
+  readonly requestStream: false;
+  readonly responseStream: true;
+  readonly requestType: typeof teletubby_pb.RegistrationMessage;
+  readonly responseType: typeof teletubby_pb.TelemetryMessage;
+};
+
+type TelemetryGatewaySendTelemetry = {
+  readonly methodName: string;
+  readonly service: typeof TelemetryGateway;
+  readonly requestStream: true;
+  readonly responseStream: false;
+  readonly requestType: typeof teletubby_pb.TelemetryMessage;
+  readonly responseType: typeof teletubby_pb.TelemetryStreamAck;
+};
+
+type TelemetryGatewaySendTelemetryMessage = {
+  readonly methodName: string;
+  readonly service: typeof TelemetryGateway;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof teletubby_pb.TelemetryMessage;
+  readonly responseType: typeof teletubby_pb.TelemetryMessageAck;
+};
+
+type TelemetryGatewayRequestTelemetry = {
+  readonly methodName: string;
+  readonly service: typeof TelemetryGateway;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof teletubby_pb.TelemetryRequest;
+  readonly responseType: typeof teletubby_pb.TelemetryRequestAck;
+};
+
+type TelemetryGatewayRequestTelemetryQuery = {
+  readonly methodName: string;
+  readonly service: typeof TelemetryGateway;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof teletubby_pb.TelemetryQueryRequest;
+  readonly responseType: typeof teletubby_pb.TelemetryRequestAck;
+};
+
+export class TelemetryGateway {
+  static readonly serviceName: string;
+  static readonly RegisterSender: TelemetryGatewayRegisterSender;
+  static readonly RegisterReceiver: TelemetryGatewayRegisterReceiver;
+  static readonly SendTelemetry: TelemetryGatewaySendTelemetry;
+  static readonly SendTelemetryMessage: TelemetryGatewaySendTelemetryMessage;
+  static readonly RequestTelemetry: TelemetryGatewayRequestTelemetry;
+  static readonly RequestTelemetryQuery: TelemetryGatewayRequestTelemetryQuery;
+}
+
+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 TelemetryReceiverClient {
+  readonly serviceHost: string;
+
+  constructor(serviceHost: string, options?: grpc.RpcOptions);
+  registerStreamReceiver(metadata?: grpc.Metadata): BidirectionalStream<teletubby_pb.ReceiverStreamMessage, teletubby_pb.TelemetryStreamMessage>;
+  requestTelemetry(
+    requestMessage: teletubby_pb.TelemetryRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: teletubby_pb.TelemetryRequestAck|null) => void
+  ): UnaryResponse;
+  requestTelemetry(
+    requestMessage: teletubby_pb.TelemetryRequest,
+    callback: (error: ServiceError|null, responseMessage: teletubby_pb.TelemetryRequestAck|null) => void
+  ): UnaryResponse;
+  requestTelemetryQuery(
+    requestMessage: teletubby_pb.TelemetryQueryRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: teletubby_pb.TelemetryRequestAck|null) => void
+  ): UnaryResponse;
+  requestTelemetryQuery(
+    requestMessage: teletubby_pb.TelemetryQueryRequest,
+    callback: (error: ServiceError|null, responseMessage: teletubby_pb.TelemetryRequestAck|null) => void
+  ): UnaryResponse;
+}
+
+export class TelemetryGatewayClient {
+  readonly serviceHost: string;
+
+  constructor(serviceHost: string, options?: grpc.RpcOptions);
+  registerSender(requestMessage: teletubby_pb.RegistrationMessage, metadata?: grpc.Metadata): ResponseStream<teletubby_pb.ConfigMessage>;
+  registerReceiver(requestMessage: teletubby_pb.RegistrationMessage, metadata?: grpc.Metadata): ResponseStream<teletubby_pb.TelemetryMessage>;
+  sendTelemetry(metadata?: grpc.Metadata): RequestStream<teletubby_pb.TelemetryMessage>;
+  sendTelemetryMessage(
+    requestMessage: teletubby_pb.TelemetryMessage,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: teletubby_pb.TelemetryMessageAck|null) => void
+  ): UnaryResponse;
+  sendTelemetryMessage(
+    requestMessage: teletubby_pb.TelemetryMessage,
+    callback: (error: ServiceError|null, responseMessage: teletubby_pb.TelemetryMessageAck|null) => void
+  ): UnaryResponse;
+  requestTelemetry(
+    requestMessage: teletubby_pb.TelemetryRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: teletubby_pb.TelemetryRequestAck|null) => void
+  ): UnaryResponse;
+  requestTelemetry(
+    requestMessage: teletubby_pb.TelemetryRequest,
+    callback: (error: ServiceError|null, responseMessage: teletubby_pb.TelemetryRequestAck|null) => void
+  ): UnaryResponse;
+  requestTelemetryQuery(
+    requestMessage: teletubby_pb.TelemetryQueryRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: teletubby_pb.TelemetryRequestAck|null) => void
+  ): UnaryResponse;
+  requestTelemetryQuery(
+    requestMessage: teletubby_pb.TelemetryQueryRequest,
+    callback: (error: ServiceError|null, responseMessage: teletubby_pb.TelemetryRequestAck|null) => void
+  ): UnaryResponse;
+}
+

package/grpc/teletubby/teletubby_pb_service.js

@@ -0,0 +1,436 @@
+// package: teletubby.v1
+// file: teletubby.proto
+
+var teletubby_pb = require("./teletubby_pb");
+var grpc = require("@improbable-eng/grpc-web").grpc;
+
+var TelemetryReceiver = (function () {
+  function TelemetryReceiver() {}
+  TelemetryReceiver.serviceName = "teletubby.v1.TelemetryReceiver";
+  return TelemetryReceiver;
+}());
+
+TelemetryReceiver.RegisterStreamReceiver = {
+  methodName: "RegisterStreamReceiver",
+  service: TelemetryReceiver,
+  requestStream: true,
+  responseStream: true,
+  requestType: teletubby_pb.ReceiverStreamMessage,
+  responseType: teletubby_pb.TelemetryStreamMessage
+};
+
+TelemetryReceiver.RequestTelemetry = {
+  methodName: "RequestTelemetry",
+  service: TelemetryReceiver,
+  requestStream: false,
+  responseStream: false,
+  requestType: teletubby_pb.TelemetryRequest,
+  responseType: teletubby_pb.TelemetryRequestAck
+};
+
+TelemetryReceiver.RequestTelemetryQuery = {
+  methodName: "RequestTelemetryQuery",
+  service: TelemetryReceiver,
+  requestStream: false,
+  responseStream: false,
+  requestType: teletubby_pb.TelemetryQueryRequest,
+  responseType: teletubby_pb.TelemetryRequestAck
+};
+
+exports.TelemetryReceiver = TelemetryReceiver;
+
+function TelemetryReceiverClient(serviceHost, options) {
+  this.serviceHost = serviceHost;
+  this.options = options || {};
+}
+
+TelemetryReceiverClient.prototype.registerStreamReceiver = function registerStreamReceiver(metadata) {
+  var listeners = {
+    data: [],
+    end: [],
+    status: []
+  };
+  var client = grpc.client(TelemetryReceiver.RegisterStreamReceiver, {
+    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();
+    }
+  };
+};
+
+TelemetryReceiverClient.prototype.requestTelemetry = function requestTelemetry(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(TelemetryReceiver.RequestTelemetry, {
+    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();
+    }
+  };
+};
+
+TelemetryReceiverClient.prototype.requestTelemetryQuery = function requestTelemetryQuery(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(TelemetryReceiver.RequestTelemetryQuery, {
+    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.TelemetryReceiverClient = TelemetryReceiverClient;
+
+var TelemetryGateway = (function () {
+  function TelemetryGateway() {}
+  TelemetryGateway.serviceName = "teletubby.v1.TelemetryGateway";
+  return TelemetryGateway;
+}());
+
+TelemetryGateway.RegisterSender = {
+  methodName: "RegisterSender",
+  service: TelemetryGateway,
+  requestStream: false,
+  responseStream: true,
+  requestType: teletubby_pb.RegistrationMessage,
+  responseType: teletubby_pb.ConfigMessage
+};
+
+TelemetryGateway.RegisterReceiver = {
+  methodName: "RegisterReceiver",
+  service: TelemetryGateway,
+  requestStream: false,
+  responseStream: true,
+  requestType: teletubby_pb.RegistrationMessage,
+  responseType: teletubby_pb.TelemetryMessage
+};
+
+TelemetryGateway.SendTelemetry = {
+  methodName: "SendTelemetry",
+  service: TelemetryGateway,
+  requestStream: true,
+  responseStream: false,
+  requestType: teletubby_pb.TelemetryMessage,
+  responseType: teletubby_pb.TelemetryStreamAck
+};
+
+TelemetryGateway.SendTelemetryMessage = {
+  methodName: "SendTelemetryMessage",
+  service: TelemetryGateway,
+  requestStream: false,
+  responseStream: false,
+  requestType: teletubby_pb.TelemetryMessage,
+  responseType: teletubby_pb.TelemetryMessageAck
+};
+
+TelemetryGateway.RequestTelemetry = {
+  methodName: "RequestTelemetry",
+  service: TelemetryGateway,
+  requestStream: false,
+  responseStream: false,
+  requestType: teletubby_pb.TelemetryRequest,
+  responseType: teletubby_pb.TelemetryRequestAck
+};
+
+TelemetryGateway.RequestTelemetryQuery = {
+  methodName: "RequestTelemetryQuery",
+  service: TelemetryGateway,
+  requestStream: false,
+  responseStream: false,
+  requestType: teletubby_pb.TelemetryQueryRequest,
+  responseType: teletubby_pb.TelemetryRequestAck
+};
+
+exports.TelemetryGateway = TelemetryGateway;
+
+function TelemetryGatewayClient(serviceHost, options) {
+  this.serviceHost = serviceHost;
+  this.options = options || {};
+}
+
+TelemetryGatewayClient.prototype.registerSender = function registerSender(requestMessage, metadata) {
+  var listeners = {
+    data: [],
+    end: [],
+    status: []
+  };
+  var client = grpc.invoke(TelemetryGateway.RegisterSender, {
+    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();
+    }
+  };
+};
+
+TelemetryGatewayClient.prototype.registerReceiver = function registerReceiver(requestMessage, metadata) {
+  var listeners = {
+    data: [],
+    end: [],
+    status: []
+  };
+  var client = grpc.invoke(TelemetryGateway.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();
+    }
+  };
+};
+
+TelemetryGatewayClient.prototype.sendTelemetry = function sendTelemetry(metadata) {
+  var listeners = {
+    end: [],
+    status: []
+  };
+  var client = grpc.client(TelemetryGateway.SendTelemetry, {
+    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();
+    }
+  };
+};
+
+TelemetryGatewayClient.prototype.sendTelemetryMessage = function sendTelemetryMessage(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(TelemetryGateway.SendTelemetryMessage, {
+    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();
+    }
+  };
+};
+
+TelemetryGatewayClient.prototype.requestTelemetry = function requestTelemetry(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(TelemetryGateway.RequestTelemetry, {
+    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();
+    }
+  };
+};
+
+TelemetryGatewayClient.prototype.requestTelemetryQuery = function requestTelemetryQuery(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(TelemetryGateway.RequestTelemetryQuery, {
+    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.TelemetryGatewayClient = TelemetryGatewayClient;
+

package/grpc/video/pigeon_grpc_pb.d.ts

@@ -0,0 +1,59 @@
+// GENERATED CODE -- DO NOT EDIT!
+
+// package: pigeon.v1
+// file: pigeon.proto
+
+import * as pigeon_pb from "./pigeon_pb";
+import * as grpc from "@grpc/grpc-js";
+
+interface IoperatorService extends grpc.ServiceDefinition<grpc.UntypedServiceImplementation> {
+  connect: grpc.MethodDefinition<pigeon_pb.OperatorConnectRequest, pigeon_pb.Message>;
+  get: grpc.MethodDefinition<pigeon_pb.GetDetailsRequest, pigeon_pb.GetDetailsResponse>;
+  offer: grpc.MethodDefinition<pigeon_pb.OfferRequest, pigeon_pb.Outcome>;
+  addIceCandidate: grpc.MethodDefinition<pigeon_pb.AddIceCandidateRequest, pigeon_pb.Outcome>;
+}
+
+export const operatorService: IoperatorService;
+
+export interface IoperatorServer extends grpc.UntypedServiceImplementation {
+  connect: grpc.handleServerStreamingCall<pigeon_pb.OperatorConnectRequest, pigeon_pb.Message>;
+  get: grpc.handleUnaryCall<pigeon_pb.GetDetailsRequest, pigeon_pb.GetDetailsResponse>;
+  offer: grpc.handleUnaryCall<pigeon_pb.OfferRequest, pigeon_pb.Outcome>;
+  addIceCandidate: grpc.handleUnaryCall<pigeon_pb.AddIceCandidateRequest, pigeon_pb.Outcome>;
+}
+
+export class operatorClient extends grpc.Client {
+  constructor(address: string, credentials: grpc.ChannelCredentials, options?: object);
+  connect(argument: pigeon_pb.OperatorConnectRequest, metadataOrOptions?: grpc.Metadata | grpc.CallOptions | null): grpc.ClientReadableStream<pigeon_pb.Message>;
+  connect(argument: pigeon_pb.OperatorConnectRequest, metadata?: grpc.Metadata | null, options?: grpc.CallOptions | null): grpc.ClientReadableStream<pigeon_pb.Message>;
+  get(argument: pigeon_pb.GetDetailsRequest, callback: grpc.requestCallback<pigeon_pb.GetDetailsResponse>): grpc.ClientUnaryCall;
+  get(argument: pigeon_pb.GetDetailsRequest, metadataOrOptions: grpc.Metadata | grpc.CallOptions | null, callback: grpc.requestCallback<pigeon_pb.GetDetailsResponse>): grpc.ClientUnaryCall;
+  get(argument: pigeon_pb.GetDetailsRequest, metadata: grpc.Metadata | null, options: grpc.CallOptions | null, callback: grpc.requestCallback<pigeon_pb.GetDetailsResponse>): grpc.ClientUnaryCall;
+  offer(argument: pigeon_pb.OfferRequest, callback: grpc.requestCallback<pigeon_pb.Outcome>): grpc.ClientUnaryCall;
+  offer(argument: pigeon_pb.OfferRequest, metadataOrOptions: grpc.Metadata | grpc.CallOptions | null, callback: grpc.requestCallback<pigeon_pb.Outcome>): grpc.ClientUnaryCall;
+  offer(argument: pigeon_pb.OfferRequest, metadata: grpc.Metadata | null, options: grpc.CallOptions | null, callback: grpc.requestCallback<pigeon_pb.Outcome>): grpc.ClientUnaryCall;
+  addIceCandidate(argument: pigeon_pb.AddIceCandidateRequest, callback: grpc.requestCallback<pigeon_pb.Outcome>): grpc.ClientUnaryCall;
+  addIceCandidate(argument: pigeon_pb.AddIceCandidateRequest, metadataOrOptions: grpc.Metadata | grpc.CallOptions | null, callback: grpc.requestCallback<pigeon_pb.Outcome>): grpc.ClientUnaryCall;
+  addIceCandidate(argument: pigeon_pb.AddIceCandidateRequest, metadata: grpc.Metadata | null, options: grpc.CallOptions | null, callback: grpc.requestCallback<pigeon_pb.Outcome>): grpc.ClientUnaryCall;
+}
+
+interface IcameraService extends grpc.ServiceDefinition<grpc.UntypedServiceImplementation> {
+  connect: grpc.MethodDefinition<pigeon_pb.CameraConnectRequest, pigeon_pb.Message>;
+  answer: grpc.MethodDefinition<pigeon_pb.AnswerRequest, pigeon_pb.Outcome>;
+}
+
+export const cameraService: IcameraService;
+
+export interface IcameraServer extends grpc.UntypedServiceImplementation {
+  connect: grpc.handleServerStreamingCall<pigeon_pb.CameraConnectRequest, pigeon_pb.Message>;
+  answer: grpc.handleUnaryCall<pigeon_pb.AnswerRequest, pigeon_pb.Outcome>;
+}
+
+export class cameraClient extends grpc.Client {
+  constructor(address: string, credentials: grpc.ChannelCredentials, options?: object);
+  connect(argument: pigeon_pb.CameraConnectRequest, metadataOrOptions?: grpc.Metadata | grpc.CallOptions | null): grpc.ClientReadableStream<pigeon_pb.Message>;
+  connect(argument: pigeon_pb.CameraConnectRequest, metadata?: grpc.Metadata | null, options?: grpc.CallOptions | null): grpc.ClientReadableStream<pigeon_pb.Message>;
+  answer(argument: pigeon_pb.AnswerRequest, callback: grpc.requestCallback<pigeon_pb.Outcome>): grpc.ClientUnaryCall;
+  answer(argument: pigeon_pb.AnswerRequest, metadataOrOptions: grpc.Metadata | grpc.CallOptions | null, callback: grpc.requestCallback<pigeon_pb.Outcome>): grpc.ClientUnaryCall;
+  answer(argument: pigeon_pb.AnswerRequest, metadata: grpc.Metadata | null, options: grpc.CallOptions | null, callback: grpc.requestCallback<pigeon_pb.Outcome>): grpc.ClientUnaryCall;
+}