@fatehan/tsrp 1.6.43 → 1.6.46

package/dist/fatehan/trips/trip.js

@@ -412,6 +412,247 @@ export const Trip = {
         return message;
     },
 };
+function createBaseShiftSummary() {
+    return {
+        id: Long.UZERO,
+        shiftId: Long.UZERO,
+        deviceId: Long.UZERO,
+        mileage: 0,
+        idling: 0,
+        parking: 0,
+        moving: 0,
+        towing: 0,
+        totalSpeed: 0,
+        sumSpeed: 0,
+        maxSpeed: 0,
+        compact: undefined,
+        startedAt: undefined,
+        finishedAt: undefined,
+        createdAt: undefined,
+        updatedAt: undefined,
+        points: [],
+    };
+}
+export const ShiftSummary = {
+    encode(message, writer = new BinaryWriter()) {
+        if (!message.id.equals(Long.UZERO)) {
+            writer.uint32(8).uint64(message.id.toString());
+        }
+        if (!message.shiftId.equals(Long.UZERO)) {
+            writer.uint32(16).uint64(message.shiftId.toString());
+        }
+        if (!message.deviceId.equals(Long.UZERO)) {
+            writer.uint32(24).uint64(message.deviceId.toString());
+        }
+        if (message.mileage !== 0) {
+            writer.uint32(32).uint32(message.mileage);
+        }
+        if (message.idling !== 0) {
+            writer.uint32(40).uint32(message.idling);
+        }
+        if (message.parking !== 0) {
+            writer.uint32(48).uint32(message.parking);
+        }
+        if (message.moving !== 0) {
+            writer.uint32(56).uint32(message.moving);
+        }
+        if (message.towing !== 0) {
+            writer.uint32(64).uint32(message.towing);
+        }
+        if (message.totalSpeed !== 0) {
+            writer.uint32(72).uint32(message.totalSpeed);
+        }
+        if (message.sumSpeed !== 0) {
+            writer.uint32(80).uint32(message.sumSpeed);
+        }
+        if (message.maxSpeed !== 0) {
+            writer.uint32(88).uint32(message.maxSpeed);
+        }
+        if (message.compact !== undefined) {
+            TripCompact.encode(message.compact, writer.uint32(98).fork()).join();
+        }
+        if (message.startedAt !== undefined) {
+            Timestamp.encode(toTimestamp(message.startedAt), writer.uint32(106).fork()).join();
+        }
+        if (message.finishedAt !== undefined) {
+            Timestamp.encode(toTimestamp(message.finishedAt), writer.uint32(114).fork()).join();
+        }
+        if (message.createdAt !== undefined) {
+            Timestamp.encode(toTimestamp(message.createdAt), writer.uint32(122).fork()).join();
+        }
+        if (message.updatedAt !== undefined) {
+            Timestamp.encode(toTimestamp(message.updatedAt), writer.uint32(130).fork()).join();
+        }
+        for (const v of message.points) {
+            TripPoint.encode(v, writer.uint32(138).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseShiftSummary();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.id = Long.fromString(reader.uint64().toString(), true);
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.shiftId = Long.fromString(reader.uint64().toString(), true);
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.deviceId = Long.fromString(reader.uint64().toString(), true);
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.mileage = reader.uint32();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 40) {
+                        break;
+                    }
+                    message.idling = reader.uint32();
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 48) {
+                        break;
+                    }
+                    message.parking = reader.uint32();
+                    continue;
+                }
+                case 7: {
+                    if (tag !== 56) {
+                        break;
+                    }
+                    message.moving = reader.uint32();
+                    continue;
+                }
+                case 8: {
+                    if (tag !== 64) {
+                        break;
+                    }
+                    message.towing = reader.uint32();
+                    continue;
+                }
+                case 9: {
+                    if (tag !== 72) {
+                        break;
+                    }
+                    message.totalSpeed = reader.uint32();
+                    continue;
+                }
+                case 10: {
+                    if (tag !== 80) {
+                        break;
+                    }
+                    message.sumSpeed = reader.uint32();
+                    continue;
+                }
+                case 11: {
+                    if (tag !== 88) {
+                        break;
+                    }
+                    message.maxSpeed = reader.uint32();
+                    continue;
+                }
+                case 12: {
+                    if (tag !== 98) {
+                        break;
+                    }
+                    message.compact = TripCompact.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 13: {
+                    if (tag !== 106) {
+                        break;
+                    }
+                    message.startedAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 14: {
+                    if (tag !== 114) {
+                        break;
+                    }
+                    message.finishedAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 15: {
+                    if (tag !== 122) {
+                        break;
+                    }
+                    message.createdAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 16: {
+                    if (tag !== 130) {
+                        break;
+                    }
+                    message.updatedAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 17: {
+                    if (tag !== 138) {
+                        break;
+                    }
+                    message.points.push(TripPoint.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return ShiftSummary.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseShiftSummary();
+        message.id = (object.id !== undefined && object.id !== null) ? Long.fromValue(object.id) : Long.UZERO;
+        message.shiftId = (object.shiftId !== undefined && object.shiftId !== null)
+            ? Long.fromValue(object.shiftId)
+            : Long.UZERO;
+        message.deviceId = (object.deviceId !== undefined && object.deviceId !== null)
+            ? Long.fromValue(object.deviceId)
+            : Long.UZERO;
+        message.mileage = object.mileage ?? 0;
+        message.idling = object.idling ?? 0;
+        message.parking = object.parking ?? 0;
+        message.moving = object.moving ?? 0;
+        message.towing = object.towing ?? 0;
+        message.totalSpeed = object.totalSpeed ?? 0;
+        message.sumSpeed = object.sumSpeed ?? 0;
+        message.maxSpeed = object.maxSpeed ?? 0;
+        message.compact = (object.compact !== undefined && object.compact !== null)
+            ? TripCompact.fromPartial(object.compact)
+            : undefined;
+        message.startedAt = object.startedAt ?? undefined;
+        message.finishedAt = object.finishedAt ?? undefined;
+        message.createdAt = object.createdAt ?? undefined;
+        message.updatedAt = object.updatedAt ?? undefined;
+        message.points = object.points?.map((e) => TripPoint.fromPartial(e)) || [];
+        return message;
+    },
+};
 function createBaseTripCompact() {
     return {
         cost: 0,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fatehan/tsrp",
-  "version": "1.6.43",
+  "version": "1.6.46",
   "description": "fatehan communication protocol",
   "repository": {
     "type": "git",