@technova-tech/olive-proto-lib 1.8.4 → 1.8.6

package/google/protobuf/struct.js

@@ -0,0 +1,357 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.google = void 0;
+const pb_1 = __importStar(require("google-protobuf"));
+var google;
+(function (google) {
+    var protobuf;
+    (function (protobuf) {
+        let NullValue;
+        (function (NullValue) {
+            NullValue[NullValue["NULL_VALUE"] = 0] = "NULL_VALUE";
+        })(NullValue = protobuf.NullValue || (protobuf.NullValue = {}));
+        class Struct extends pb_1.Message {
+            #one_of_decls = [];
+            constructor(data) {
+                super();
+                pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
+                if (!Array.isArray(data) && typeof data == "object") {
+                    if ("fields" in data && data.fields != undefined) {
+                        this.fields = data.fields;
+                    }
+                }
+                if (!this.fields)
+                    this.fields = new Map();
+            }
+            get fields() {
+                return pb_1.Message.getField(this, 1);
+            }
+            set fields(value) {
+                pb_1.Message.setField(this, 1, value);
+            }
+            static fromObject(data) {
+                const message = new Struct({});
+                if (typeof data.fields == "object") {
+                    message.fields = new Map(Object.entries(data.fields).map(([key, value]) => [key, Value.fromObject(value)]));
+                }
+                return message;
+            }
+            toObject() {
+                const data = {};
+                if (this.fields != null) {
+                    data.fields = (Object.fromEntries)((Array.from)(this.fields).map(([key, value]) => [key, value.toObject()]));
+                }
+                return data;
+            }
+            serialize(w) {
+                const writer = w || new pb_1.BinaryWriter();
+                for (const [key, value] of this.fields) {
+                    writer.writeMessage(1, this.fields, () => {
+                        writer.writeString(1, key);
+                        writer.writeMessage(2, value, () => value.serialize(writer));
+                    });
+                }
+                if (!w)
+                    return writer.getResultBuffer();
+            }
+            static deserialize(bytes) {
+                const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new Struct();
+                while (reader.nextField()) {
+                    if (reader.isEndGroup())
+                        break;
+                    switch (reader.getFieldNumber()) {
+                        case 1:
+                            reader.readMessage(message, () => pb_1.Map.deserializeBinary(message.fields, reader, reader.readString, () => {
+                                let value;
+                                reader.readMessage(message, () => value = Value.deserialize(reader));
+                                return value;
+                            }));
+                            break;
+                        default: reader.skipField();
+                    }
+                }
+                return message;
+            }
+            serializeBinary() {
+                return this.serialize();
+            }
+            static deserializeBinary(bytes) {
+                return Struct.deserialize(bytes);
+            }
+        }
+        protobuf.Struct = Struct;
+        class Value extends pb_1.Message {
+            #one_of_decls = [[1, 2, 3, 4, 5, 6]];
+            constructor(data) {
+                super();
+                pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
+                if (!Array.isArray(data) && typeof data == "object") {
+                    if ("nullValue" in data && data.nullValue != undefined) {
+                        this.nullValue = data.nullValue;
+                    }
+                    if ("numberValue" in data && data.numberValue != undefined) {
+                        this.numberValue = data.numberValue;
+                    }
+                    if ("stringValue" in data && data.stringValue != undefined) {
+                        this.stringValue = data.stringValue;
+                    }
+                    if ("boolValue" in data && data.boolValue != undefined) {
+                        this.boolValue = data.boolValue;
+                    }
+                    if ("structValue" in data && data.structValue != undefined) {
+                        this.structValue = data.structValue;
+                    }
+                    if ("listValue" in data && data.listValue != undefined) {
+                        this.listValue = data.listValue;
+                    }
+                }
+            }
+            get nullValue() {
+                return pb_1.Message.getFieldWithDefault(this, 1, NullValue.NULL_VALUE);
+            }
+            set nullValue(value) {
+                pb_1.Message.setOneofField(this, 1, this.#one_of_decls[0], value);
+            }
+            get hasNullValue() {
+                return pb_1.Message.getField(this, 1) != null;
+            }
+            get numberValue() {
+                return pb_1.Message.getFieldWithDefault(this, 2, 0);
+            }
+            set numberValue(value) {
+                pb_1.Message.setOneofField(this, 2, this.#one_of_decls[0], value);
+            }
+            get hasNumberValue() {
+                return pb_1.Message.getField(this, 2) != null;
+            }
+            get stringValue() {
+                return pb_1.Message.getFieldWithDefault(this, 3, "");
+            }
+            set stringValue(value) {
+                pb_1.Message.setOneofField(this, 3, this.#one_of_decls[0], value);
+            }
+            get hasStringValue() {
+                return pb_1.Message.getField(this, 3) != null;
+            }
+            get boolValue() {
+                return pb_1.Message.getFieldWithDefault(this, 4, false);
+            }
+            set boolValue(value) {
+                pb_1.Message.setOneofField(this, 4, this.#one_of_decls[0], value);
+            }
+            get hasBoolValue() {
+                return pb_1.Message.getField(this, 4) != null;
+            }
+            get structValue() {
+                return pb_1.Message.getWrapperField(this, Struct, 5);
+            }
+            set structValue(value) {
+                pb_1.Message.setOneofWrapperField(this, 5, this.#one_of_decls[0], value);
+            }
+            get hasStructValue() {
+                return pb_1.Message.getField(this, 5) != null;
+            }
+            get listValue() {
+                return pb_1.Message.getWrapperField(this, ListValue, 6);
+            }
+            set listValue(value) {
+                pb_1.Message.setOneofWrapperField(this, 6, this.#one_of_decls[0], value);
+            }
+            get hasListValue() {
+                return pb_1.Message.getField(this, 6) != null;
+            }
+            get kind() {
+                const cases = {
+                    0: "none",
+                    1: "nullValue",
+                    2: "numberValue",
+                    3: "stringValue",
+                    4: "boolValue",
+                    5: "structValue",
+                    6: "listValue"
+                };
+                return cases[pb_1.Message.computeOneofCase(this, [1, 2, 3, 4, 5, 6])];
+            }
+            static fromObject(data) {
+                const message = new Value({});
+                if (data.nullValue != null) {
+                    message.nullValue = data.nullValue;
+                }
+                if (data.numberValue != null) {
+                    message.numberValue = data.numberValue;
+                }
+                if (data.stringValue != null) {
+                    message.stringValue = data.stringValue;
+                }
+                if (data.boolValue != null) {
+                    message.boolValue = data.boolValue;
+                }
+                if (data.structValue != null) {
+                    message.structValue = Struct.fromObject(data.structValue);
+                }
+                if (data.listValue != null) {
+                    message.listValue = ListValue.fromObject(data.listValue);
+                }
+                return message;
+            }
+            toObject() {
+                const data = {};
+                if (this.nullValue != null) {
+                    data.nullValue = this.nullValue;
+                }
+                if (this.numberValue != null) {
+                    data.numberValue = this.numberValue;
+                }
+                if (this.stringValue != null) {
+                    data.stringValue = this.stringValue;
+                }
+                if (this.boolValue != null) {
+                    data.boolValue = this.boolValue;
+                }
+                if (this.structValue != null) {
+                    data.structValue = this.structValue.toObject();
+                }
+                if (this.listValue != null) {
+                    data.listValue = this.listValue.toObject();
+                }
+                return data;
+            }
+            serialize(w) {
+                const writer = w || new pb_1.BinaryWriter();
+                if (this.hasNullValue)
+                    writer.writeEnum(1, this.nullValue);
+                if (this.hasNumberValue)
+                    writer.writeDouble(2, this.numberValue);
+                if (this.hasStringValue)
+                    writer.writeString(3, this.stringValue);
+                if (this.hasBoolValue)
+                    writer.writeBool(4, this.boolValue);
+                if (this.hasStructValue)
+                    writer.writeMessage(5, this.structValue, () => this.structValue.serialize(writer));
+                if (this.hasListValue)
+                    writer.writeMessage(6, this.listValue, () => this.listValue.serialize(writer));
+                if (!w)
+                    return writer.getResultBuffer();
+            }
+            static deserialize(bytes) {
+                const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new Value();
+                while (reader.nextField()) {
+                    if (reader.isEndGroup())
+                        break;
+                    switch (reader.getFieldNumber()) {
+                        case 1:
+                            message.nullValue = reader.readEnum();
+                            break;
+                        case 2:
+                            message.numberValue = reader.readDouble();
+                            break;
+                        case 3:
+                            message.stringValue = reader.readString();
+                            break;
+                        case 4:
+                            message.boolValue = reader.readBool();
+                            break;
+                        case 5:
+                            reader.readMessage(message.structValue, () => message.structValue = Struct.deserialize(reader));
+                            break;
+                        case 6:
+                            reader.readMessage(message.listValue, () => message.listValue = ListValue.deserialize(reader));
+                            break;
+                        default: reader.skipField();
+                    }
+                }
+                return message;
+            }
+            serializeBinary() {
+                return this.serialize();
+            }
+            static deserializeBinary(bytes) {
+                return Value.deserialize(bytes);
+            }
+        }
+        protobuf.Value = Value;
+        class ListValue extends pb_1.Message {
+            #one_of_decls = [];
+            constructor(data) {
+                super();
+                pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [1], this.#one_of_decls);
+                if (!Array.isArray(data) && typeof data == "object") {
+                    if ("values" in data && data.values != undefined) {
+                        this.values = data.values;
+                    }
+                }
+            }
+            get values() {
+                return pb_1.Message.getRepeatedWrapperField(this, Value, 1);
+            }
+            set values(value) {
+                pb_1.Message.setRepeatedWrapperField(this, 1, value);
+            }
+            static fromObject(data) {
+                const message = new ListValue({});
+                if (data.values != null) {
+                    message.values = data.values.map(item => Value.fromObject(item));
+                }
+                return message;
+            }
+            toObject() {
+                const data = {};
+                if (this.values != null) {
+                    data.values = this.values.map((item) => item.toObject());
+                }
+                return data;
+            }
+            serialize(w) {
+                const writer = w || new pb_1.BinaryWriter();
+                if (this.values.length)
+                    writer.writeRepeatedMessage(1, this.values, (item) => item.serialize(writer));
+                if (!w)
+                    return writer.getResultBuffer();
+            }
+            static deserialize(bytes) {
+                const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new ListValue();
+                while (reader.nextField()) {
+                    if (reader.isEndGroup())
+                        break;
+                    switch (reader.getFieldNumber()) {
+                        case 1:
+                            reader.readMessage(message.values, () => pb_1.Message.addToRepeatedWrapperField(message, 1, Value.deserialize(reader), Value));
+                            break;
+                        default: reader.skipField();
+                    }
+                }
+                return message;
+            }
+            serializeBinary() {
+                return this.serialize();
+            }
+            static deserializeBinary(bytes) {
+                return ListValue.deserialize(bytes);
+            }
+        }
+        protobuf.ListValue = ListValue;
+    })(protobuf = google.protobuf || (google.protobuf = {}));
+})(google || (exports.google = google = {}));

package/package.json

@@ -6,12 +6,12 @@
   "module": "index",
   "types": "types",
   "scripts": {
-    "build": "rm -rf src && mkdir src && protoc --plugin=protoc-gen-ts=$PWD/node_modules/.bin/protoc-gen-ts --ts_out=src --ts_opt=unary_rpc_promise=true --ts_opt=target=node --ts_opt=json_names -I=proto proto/**/*.proto",
-    "build:next": "rm -rf src && mkdir src && protoc-25.3.0 --plugin=protoc-gen-ts=$PWD/node_modules/.bin/protoc-gen-ts --ts_out=src --ts_opt=unary_rpc_promise=true --ts_opt=target=node --ts_opt=json_names -I=proto proto/**/*.proto",
+    "build": "rm -rf src && mkdir src && protoc --plugin=protoc-gen-ts=$PWD/node_modules/.bin/protoc-gen-ts --ts_out=src --ts_opt=unary_rpc_promise=true --ts_opt=target=node --ts_opt=json_names -I=proto -I=node_modules/google-protobuf proto/**/*.proto",
+    "build:next": "rm -rf src && mkdir src && protoc-25.3.0 --plugin=protoc-gen-ts=$PWD/node_modules/.bin/protoc-gen-ts --ts_out=src --ts_opt=unary_rpc_promise=true --ts_opt=target=node --ts_opt=json_names -I=proto -I=node_modules/google-protobuf proto/**/*.proto",
     "compile": "tsc -p tsconfig.json"
   },
   "license": "MIT",
-  "version": "1.8.4",
+  "version": "1.8.6",
   "devDependencies": {
     "@types/google-protobuf": "^3.15.12",
     "protoc-gen-ts": "^0.8.7",

package/pos.v1/terminals.js

@@ -10399,6 +10399,9 @@ var com;
                             if ("notes" in data && data.notes != undefined) {
                                 this.notes = data.notes;
                             }
+                            if ("processorTid" in data && data.processorTid != undefined) {
+                                this.processorTid = data.processorTid;
+                            }
                         }
                         if (!this.deviceConfiguration)
                             this.deviceConfiguration = new Map();
@@ -10445,6 +10448,12 @@ var com;
                     set notes(value) {
                         pb_1.Message.setField(this, 7, value);
                     }
+                    get processorTid() {
+                        return pb_1.Message.getFieldWithDefault(this, 8, "");
+                    }
+                    set processorTid(value) {
+                        pb_1.Message.setField(this, 8, value);
+                    }
                     static fromObject(data) {
                         const message = new TerminalBulkData({});
                         if (data.serialNumber != null) {
@@ -10468,6 +10477,9 @@ var com;
                         if (data.notes != null) {
                             message.notes = data.notes;
                         }
+                        if (data.processorTid != null) {
+                            message.processorTid = data.processorTid;
+                        }
                         return message;
                     }
                     toObject() {
@@ -10493,6 +10505,9 @@ var com;
                         if (this.notes != null) {
                             data.notes = this.notes;
                         }
+                        if (this.processorTid != null) {
+                            data.processorTid = this.processorTid;
+                        }
                         return data;
                     }
                     serialize(w) {
@@ -10515,6 +10530,8 @@ var com;
                         }
                         if (this.notes.length)
                             writer.writeString(7, this.notes);
+                        if (this.processorTid.length)
+                            writer.writeString(8, this.processorTid);
                         if (!w)
                             return writer.getResultBuffer();
                     }
@@ -10545,6 +10562,9 @@ var com;
                                 case 7:
                                     message.notes = reader.readString();
                                     break;
+                                case 8:
+                                    message.processorTid = reader.readString();
+                                    break;
                                 default: reader.skipField();
                             }
                         }