@aceplus/smartace-api 2.11.0-alpha.4 → 2.11.0-alpha.6

package/meta.spic_config_pb_service.d.ts

@@ -0,0 +1,122 @@
+// package: Meta
+// file: meta.spic_config.proto
+
+import * as meta_spic_config_pb from "./meta.spic_config_pb";
+import * as google_protobuf_empty_pb from "google-protobuf/google/protobuf/empty_pb";
+import * as spic_cabinet_pb from "./spic.cabinet_pb";
+import {grpc} from "@improbable-eng/grpc-web";
+
+type CabinetMetaGRPCRetrieve = {
+  readonly methodName: string;
+  readonly service: typeof CabinetMetaGRPC;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof spic_cabinet_pb.CabinetProto.RetrieveRequest;
+  readonly responseType: typeof meta_spic_config_pb.CabinetLocationMeta;
+};
+
+type CabinetMetaGRPCSetTemperatureConfiguration = {
+  readonly methodName: string;
+  readonly service: typeof CabinetMetaGRPC;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof meta_spic_config_pb.TemperatureConfigurationProto.SetConfigurationRequest;
+  readonly responseType: typeof google_protobuf_empty_pb.Empty;
+};
+
+type CabinetMetaGRPCCreateTemperatureConfigurationTemplate = {
+  readonly methodName: string;
+  readonly service: typeof CabinetMetaGRPC;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof meta_spic_config_pb.TemperatureConfigurationProto.CreateTemplateRequest;
+  readonly responseType: typeof google_protobuf_empty_pb.Empty;
+};
+
+type CabinetMetaGRPCSearchTemperatureConfigurationTemplate = {
+  readonly methodName: string;
+  readonly service: typeof CabinetMetaGRPC;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof meta_spic_config_pb.TemperatureConfigurationProto.SearchTemplateRequest;
+  readonly responseType: typeof meta_spic_config_pb.TemperatureConfigurationProto.SearchTemplateReply;
+};
+
+export class CabinetMetaGRPC {
+  static readonly serviceName: string;
+  static readonly Retrieve: CabinetMetaGRPCRetrieve;
+  static readonly SetTemperatureConfiguration: CabinetMetaGRPCSetTemperatureConfiguration;
+  static readonly CreateTemperatureConfigurationTemplate: CabinetMetaGRPCCreateTemperatureConfigurationTemplate;
+  static readonly SearchTemperatureConfigurationTemplate: CabinetMetaGRPCSearchTemperatureConfigurationTemplate;
+}
+
+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 CabinetMetaGRPCClient {
+  readonly serviceHost: string;
+
+  constructor(serviceHost: string, options?: grpc.RpcOptions);
+  retrieve(
+    requestMessage: spic_cabinet_pb.CabinetProto.RetrieveRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: meta_spic_config_pb.CabinetLocationMeta|null) => void
+  ): UnaryResponse;
+  retrieve(
+    requestMessage: spic_cabinet_pb.CabinetProto.RetrieveRequest,
+    callback: (error: ServiceError|null, responseMessage: meta_spic_config_pb.CabinetLocationMeta|null) => void
+  ): UnaryResponse;
+  setTemperatureConfiguration(
+    requestMessage: meta_spic_config_pb.TemperatureConfigurationProto.SetConfigurationRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: google_protobuf_empty_pb.Empty|null) => void
+  ): UnaryResponse;
+  setTemperatureConfiguration(
+    requestMessage: meta_spic_config_pb.TemperatureConfigurationProto.SetConfigurationRequest,
+    callback: (error: ServiceError|null, responseMessage: google_protobuf_empty_pb.Empty|null) => void
+  ): UnaryResponse;
+  createTemperatureConfigurationTemplate(
+    requestMessage: meta_spic_config_pb.TemperatureConfigurationProto.CreateTemplateRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: google_protobuf_empty_pb.Empty|null) => void
+  ): UnaryResponse;
+  createTemperatureConfigurationTemplate(
+    requestMessage: meta_spic_config_pb.TemperatureConfigurationProto.CreateTemplateRequest,
+    callback: (error: ServiceError|null, responseMessage: google_protobuf_empty_pb.Empty|null) => void
+  ): UnaryResponse;
+  searchTemperatureConfigurationTemplate(
+    requestMessage: meta_spic_config_pb.TemperatureConfigurationProto.SearchTemplateRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: meta_spic_config_pb.TemperatureConfigurationProto.SearchTemplateReply|null) => void
+  ): UnaryResponse;
+  searchTemperatureConfigurationTemplate(
+    requestMessage: meta_spic_config_pb.TemperatureConfigurationProto.SearchTemplateRequest,
+    callback: (error: ServiceError|null, responseMessage: meta_spic_config_pb.TemperatureConfigurationProto.SearchTemplateReply|null) => void
+  ): UnaryResponse;
+}
+

package/meta.spic_config_pb_service.js

@@ -0,0 +1,183 @@
+// package: Meta
+// file: meta.spic_config.proto
+
+var meta_spic_config_pb = require("./meta.spic_config_pb");
+var google_protobuf_empty_pb = require("google-protobuf/google/protobuf/empty_pb");
+var spic_cabinet_pb = require("./spic.cabinet_pb");
+var grpc = require("@improbable-eng/grpc-web").grpc;
+
+var CabinetMetaGRPC = (function () {
+  function CabinetMetaGRPC() {}
+  CabinetMetaGRPC.serviceName = "Meta.CabinetMetaGRPC";
+  return CabinetMetaGRPC;
+}());
+
+CabinetMetaGRPC.Retrieve = {
+  methodName: "Retrieve",
+  service: CabinetMetaGRPC,
+  requestStream: false,
+  responseStream: false,
+  requestType: spic_cabinet_pb.CabinetProto.RetrieveRequest,
+  responseType: meta_spic_config_pb.CabinetLocationMeta
+};
+
+CabinetMetaGRPC.SetTemperatureConfiguration = {
+  methodName: "SetTemperatureConfiguration",
+  service: CabinetMetaGRPC,
+  requestStream: false,
+  responseStream: false,
+  requestType: meta_spic_config_pb.TemperatureConfigurationProto.SetConfigurationRequest,
+  responseType: google_protobuf_empty_pb.Empty
+};
+
+CabinetMetaGRPC.CreateTemperatureConfigurationTemplate = {
+  methodName: "CreateTemperatureConfigurationTemplate",
+  service: CabinetMetaGRPC,
+  requestStream: false,
+  responseStream: false,
+  requestType: meta_spic_config_pb.TemperatureConfigurationProto.CreateTemplateRequest,
+  responseType: google_protobuf_empty_pb.Empty
+};
+
+CabinetMetaGRPC.SearchTemperatureConfigurationTemplate = {
+  methodName: "SearchTemperatureConfigurationTemplate",
+  service: CabinetMetaGRPC,
+  requestStream: false,
+  responseStream: false,
+  requestType: meta_spic_config_pb.TemperatureConfigurationProto.SearchTemplateRequest,
+  responseType: meta_spic_config_pb.TemperatureConfigurationProto.SearchTemplateReply
+};
+
+exports.CabinetMetaGRPC = CabinetMetaGRPC;
+
+function CabinetMetaGRPCClient(serviceHost, options) {
+  this.serviceHost = serviceHost;
+  this.options = options || {};
+}
+
+CabinetMetaGRPCClient.prototype.retrieve = function retrieve(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(CabinetMetaGRPC.Retrieve, {
+    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();
+    }
+  };
+};
+
+CabinetMetaGRPCClient.prototype.setTemperatureConfiguration = function setTemperatureConfiguration(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(CabinetMetaGRPC.SetTemperatureConfiguration, {
+    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();
+    }
+  };
+};
+
+CabinetMetaGRPCClient.prototype.createTemperatureConfigurationTemplate = function createTemperatureConfigurationTemplate(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(CabinetMetaGRPC.CreateTemperatureConfigurationTemplate, {
+    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();
+    }
+  };
+};
+
+CabinetMetaGRPCClient.prototype.searchTemperatureConfigurationTemplate = function searchTemperatureConfigurationTemplate(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(CabinetMetaGRPC.SearchTemperatureConfigurationTemplate, {
+    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.CabinetMetaGRPCClient = CabinetMetaGRPCClient;
+

package/package.json

@@ -5,7 +5,7 @@
     "grpc-web": "^1.4.2",
     "ts-protoc-gen": "^0.15.0"
   },
-  "version": "2.11.0-alpha.4",
+  "version": "2.11.0-alpha.6",
   "description": "Generated proto files.",
   "author": "TKF",
   "files": [

package/spic.cabinet_pb.d.ts

@@ -562,6 +562,9 @@ export namespace CabinetProto {
     getBatteryTemperature(): number;
     setBatteryTemperature(value: number): void;
 
+    getOpenRequestId(): number;
+    setOpenRequestId(value: number): void;
+
     serializeBinary(): Uint8Array;
     toObject(includeInstance?: boolean): State.AsObject;
     static toObject(includeInstance: boolean, msg: State): State.AsObject;
@@ -597,6 +600,7 @@ export namespace CabinetProto {
       batteryUnloaded: number,
       batteryLoaded: number,
       batteryTemperature: number,
+      openRequestId: number,
     }
 
     export class SearchRequest extends jspb.Message {

package/spic.cabinet_pb.js

@@ -3817,7 +3817,8 @@ proto.Spic.CabinetProto.State.toObject = function(includeInstance, msg) {
     communicationTime: jspb.Message.getFieldWithDefault(msg, 20, 0),
     batteryUnloaded: jspb.Message.getFieldWithDefault(msg, 21, 0),
     batteryLoaded: jspb.Message.getFieldWithDefault(msg, 22, 0),
-    batteryTemperature: jspb.Message.getFieldWithDefault(msg, 23, 0)
+    batteryTemperature: jspb.Message.getFieldWithDefault(msg, 23, 0),
+    openRequestId: jspb.Message.getFieldWithDefault(msg, 24, 0)
   };
 
   if (includeInstance) {
@@ -3949,6 +3950,10 @@ proto.Spic.CabinetProto.State.deserializeBinaryFromReader = function(msg, reader
       var value = /** @type {number} */ (reader.readInt32());
       msg.setBatteryTemperature(value);
       break;
+    case 24:
+      var value = /** @type {number} */ (reader.readInt64());
+      msg.setOpenRequestId(value);
+      break;
     default:
       reader.skipField();
       break;
@@ -4140,6 +4145,13 @@ proto.Spic.CabinetProto.State.serializeBinaryToWriter = function(message, writer
       f
     );
   }
+  f = message.getOpenRequestId();
+  if (f !== 0) {
+    writer.writeInt64(
+      24,
+      f
+    );
+  }
 };
 
 
@@ -5447,6 +5459,24 @@ proto.Spic.CabinetProto.State.prototype.setBatteryTemperature = function(value)
 };
 
 
+/**
+ * optional int64 open_request_id = 24;
+ * @return {number}
+ */
+proto.Spic.CabinetProto.State.prototype.getOpenRequestId = function() {
+  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 24, 0));
+};
+
+
+/**
+ * @param {number} value
+ * @return {!proto.Spic.CabinetProto.State} returns this
+ */
+proto.Spic.CabinetProto.State.prototype.setOpenRequestId = function(value) {
+  return jspb.Message.setProto3IntField(this, 24, value);
+};
+
+