@ekhein/lamda-node-sdk 1.0.1 → 1.0.2

package/dist/rpc/status.cjs

@@ -0,0 +1,936 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/rpc/status.ts
+var status_exports = {};
+__export(status_exports, {
+  BatteryInfo: () => BatteryInfo,
+  CpuInfo: () => CpuInfo,
+  DiskIOInfo: () => DiskIOInfo,
+  DiskUsage: () => DiskUsage,
+  MemInfo: () => MemInfo,
+  NetIOInfo: () => NetIOInfo,
+  protobufPackage: () => protobufPackage
+});
+module.exports = __toCommonJS(status_exports);
+var import_wire = require("@bufbuild/protobuf/wire");
+var protobufPackage = "lamda.rpc";
+function createBaseBatteryInfo() {
+  return { battCharging: false, battPercent: 0, battTemperature: 0 };
+}
+var BatteryInfo = {
+  encode(message, writer = new import_wire.BinaryWriter()) {
+    if (message.battCharging !== false) {
+      writer.uint32(8).bool(message.battCharging);
+    }
+    if (message.battPercent !== 0) {
+      writer.uint32(16).int32(message.battPercent);
+    }
+    if (message.battTemperature !== 0) {
+      writer.uint32(29).float(message.battTemperature);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseBatteryInfo();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+          message.battCharging = reader.bool();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.battPercent = reader.int32();
+          continue;
+        }
+        case 3: {
+          if (tag !== 29) {
+            break;
+          }
+          message.battTemperature = reader.float();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      battCharging: isSet(object.battCharging) ? globalThis.Boolean(object.battCharging) : false,
+      battPercent: isSet(object.battPercent) ? globalThis.Number(object.battPercent) : 0,
+      battTemperature: isSet(object.battTemperature) ? globalThis.Number(object.battTemperature) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.battCharging !== false) {
+      obj.battCharging = message.battCharging;
+    }
+    if (message.battPercent !== 0) {
+      obj.battPercent = Math.round(message.battPercent);
+    }
+    if (message.battTemperature !== 0) {
+      obj.battTemperature = message.battTemperature;
+    }
+    return obj;
+  },
+  create(base) {
+    return BatteryInfo.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseBatteryInfo();
+    message.battCharging = object.battCharging ?? false;
+    message.battPercent = object.battPercent ?? 0;
+    message.battTemperature = object.battTemperature ?? 0;
+    return message;
+  }
+};
+function createBaseCpuInfo() {
+  return {
+    cpuPercent: 0,
+    cpuCount: 0,
+    cpuFreqCurrent: 0,
+    cpuFreqMax: 0,
+    cpuFreqMin: 0,
+    cpuTimesUser: 0,
+    cpuTimesSystem: 0,
+    cpuTimesIdle: 0
+  };
+}
+var CpuInfo = {
+  encode(message, writer = new import_wire.BinaryWriter()) {
+    if (message.cpuPercent !== 0) {
+      writer.uint32(13).float(message.cpuPercent);
+    }
+    if (message.cpuCount !== 0) {
+      writer.uint32(16).int32(message.cpuCount);
+    }
+    if (message.cpuFreqCurrent !== 0) {
+      writer.uint32(29).float(message.cpuFreqCurrent);
+    }
+    if (message.cpuFreqMax !== 0) {
+      writer.uint32(37).float(message.cpuFreqMax);
+    }
+    if (message.cpuFreqMin !== 0) {
+      writer.uint32(45).float(message.cpuFreqMin);
+    }
+    if (message.cpuTimesUser !== 0) {
+      writer.uint32(53).float(message.cpuTimesUser);
+    }
+    if (message.cpuTimesSystem !== 0) {
+      writer.uint32(61).float(message.cpuTimesSystem);
+    }
+    if (message.cpuTimesIdle !== 0) {
+      writer.uint32(69).float(message.cpuTimesIdle);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseCpuInfo();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 13) {
+            break;
+          }
+          message.cpuPercent = reader.float();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.cpuCount = reader.int32();
+          continue;
+        }
+        case 3: {
+          if (tag !== 29) {
+            break;
+          }
+          message.cpuFreqCurrent = reader.float();
+          continue;
+        }
+        case 4: {
+          if (tag !== 37) {
+            break;
+          }
+          message.cpuFreqMax = reader.float();
+          continue;
+        }
+        case 5: {
+          if (tag !== 45) {
+            break;
+          }
+          message.cpuFreqMin = reader.float();
+          continue;
+        }
+        case 6: {
+          if (tag !== 53) {
+            break;
+          }
+          message.cpuTimesUser = reader.float();
+          continue;
+        }
+        case 7: {
+          if (tag !== 61) {
+            break;
+          }
+          message.cpuTimesSystem = reader.float();
+          continue;
+        }
+        case 8: {
+          if (tag !== 69) {
+            break;
+          }
+          message.cpuTimesIdle = reader.float();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      cpuPercent: isSet(object.cpuPercent) ? globalThis.Number(object.cpuPercent) : 0,
+      cpuCount: isSet(object.cpuCount) ? globalThis.Number(object.cpuCount) : 0,
+      cpuFreqCurrent: isSet(object.cpuFreqCurrent) ? globalThis.Number(object.cpuFreqCurrent) : 0,
+      cpuFreqMax: isSet(object.cpuFreqMax) ? globalThis.Number(object.cpuFreqMax) : 0,
+      cpuFreqMin: isSet(object.cpuFreqMin) ? globalThis.Number(object.cpuFreqMin) : 0,
+      cpuTimesUser: isSet(object.cpuTimesUser) ? globalThis.Number(object.cpuTimesUser) : 0,
+      cpuTimesSystem: isSet(object.cpuTimesSystem) ? globalThis.Number(object.cpuTimesSystem) : 0,
+      cpuTimesIdle: isSet(object.cpuTimesIdle) ? globalThis.Number(object.cpuTimesIdle) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.cpuPercent !== 0) {
+      obj.cpuPercent = message.cpuPercent;
+    }
+    if (message.cpuCount !== 0) {
+      obj.cpuCount = Math.round(message.cpuCount);
+    }
+    if (message.cpuFreqCurrent !== 0) {
+      obj.cpuFreqCurrent = message.cpuFreqCurrent;
+    }
+    if (message.cpuFreqMax !== 0) {
+      obj.cpuFreqMax = message.cpuFreqMax;
+    }
+    if (message.cpuFreqMin !== 0) {
+      obj.cpuFreqMin = message.cpuFreqMin;
+    }
+    if (message.cpuTimesUser !== 0) {
+      obj.cpuTimesUser = message.cpuTimesUser;
+    }
+    if (message.cpuTimesSystem !== 0) {
+      obj.cpuTimesSystem = message.cpuTimesSystem;
+    }
+    if (message.cpuTimesIdle !== 0) {
+      obj.cpuTimesIdle = message.cpuTimesIdle;
+    }
+    return obj;
+  },
+  create(base) {
+    return CpuInfo.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseCpuInfo();
+    message.cpuPercent = object.cpuPercent ?? 0;
+    message.cpuCount = object.cpuCount ?? 0;
+    message.cpuFreqCurrent = object.cpuFreqCurrent ?? 0;
+    message.cpuFreqMax = object.cpuFreqMax ?? 0;
+    message.cpuFreqMin = object.cpuFreqMin ?? 0;
+    message.cpuTimesUser = object.cpuTimesUser ?? 0;
+    message.cpuTimesSystem = object.cpuTimesSystem ?? 0;
+    message.cpuTimesIdle = object.cpuTimesIdle ?? 0;
+    return message;
+  }
+};
+function createBaseDiskUsage() {
+  return { diskTotal: 0, diskUsed: 0, diskFree: 0, diskPercent: 0 };
+}
+var DiskUsage = {
+  encode(message, writer = new import_wire.BinaryWriter()) {
+    if (message.diskTotal !== 0) {
+      writer.uint32(8).int64(message.diskTotal);
+    }
+    if (message.diskUsed !== 0) {
+      writer.uint32(16).int64(message.diskUsed);
+    }
+    if (message.diskFree !== 0) {
+      writer.uint32(24).int64(message.diskFree);
+    }
+    if (message.diskPercent !== 0) {
+      writer.uint32(37).float(message.diskPercent);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseDiskUsage();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+          message.diskTotal = longToNumber(reader.int64());
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.diskUsed = longToNumber(reader.int64());
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+          message.diskFree = longToNumber(reader.int64());
+          continue;
+        }
+        case 4: {
+          if (tag !== 37) {
+            break;
+          }
+          message.diskPercent = reader.float();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      diskTotal: isSet(object.diskTotal) ? globalThis.Number(object.diskTotal) : 0,
+      diskUsed: isSet(object.diskUsed) ? globalThis.Number(object.diskUsed) : 0,
+      diskFree: isSet(object.diskFree) ? globalThis.Number(object.diskFree) : 0,
+      diskPercent: isSet(object.diskPercent) ? globalThis.Number(object.diskPercent) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.diskTotal !== 0) {
+      obj.diskTotal = Math.round(message.diskTotal);
+    }
+    if (message.diskUsed !== 0) {
+      obj.diskUsed = Math.round(message.diskUsed);
+    }
+    if (message.diskFree !== 0) {
+      obj.diskFree = Math.round(message.diskFree);
+    }
+    if (message.diskPercent !== 0) {
+      obj.diskPercent = message.diskPercent;
+    }
+    return obj;
+  },
+  create(base) {
+    return DiskUsage.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseDiskUsage();
+    message.diskTotal = object.diskTotal ?? 0;
+    message.diskUsed = object.diskUsed ?? 0;
+    message.diskFree = object.diskFree ?? 0;
+    message.diskPercent = object.diskPercent ?? 0;
+    return message;
+  }
+};
+function createBaseDiskIOInfo() {
+  return {
+    diskIoReadBytes: 0,
+    diskIoReadCount: 0,
+    diskIoWriteBytes: 0,
+    diskIoWriteCount: 0,
+    diskIoReadTime: 0,
+    diskIoWriteTime: 0,
+    diskIoBusyTime: 0
+  };
+}
+var DiskIOInfo = {
+  encode(message, writer = new import_wire.BinaryWriter()) {
+    if (message.diskIoReadBytes !== 0) {
+      writer.uint32(8).int64(message.diskIoReadBytes);
+    }
+    if (message.diskIoReadCount !== 0) {
+      writer.uint32(16).int64(message.diskIoReadCount);
+    }
+    if (message.diskIoWriteBytes !== 0) {
+      writer.uint32(24).int64(message.diskIoWriteBytes);
+    }
+    if (message.diskIoWriteCount !== 0) {
+      writer.uint32(32).int64(message.diskIoWriteCount);
+    }
+    if (message.diskIoReadTime !== 0) {
+      writer.uint32(40).int64(message.diskIoReadTime);
+    }
+    if (message.diskIoWriteTime !== 0) {
+      writer.uint32(48).int64(message.diskIoWriteTime);
+    }
+    if (message.diskIoBusyTime !== 0) {
+      writer.uint32(56).int64(message.diskIoBusyTime);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseDiskIOInfo();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+          message.diskIoReadBytes = longToNumber(reader.int64());
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.diskIoReadCount = longToNumber(reader.int64());
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+          message.diskIoWriteBytes = longToNumber(reader.int64());
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+          message.diskIoWriteCount = longToNumber(reader.int64());
+          continue;
+        }
+        case 5: {
+          if (tag !== 40) {
+            break;
+          }
+          message.diskIoReadTime = longToNumber(reader.int64());
+          continue;
+        }
+        case 6: {
+          if (tag !== 48) {
+            break;
+          }
+          message.diskIoWriteTime = longToNumber(reader.int64());
+          continue;
+        }
+        case 7: {
+          if (tag !== 56) {
+            break;
+          }
+          message.diskIoBusyTime = longToNumber(reader.int64());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      diskIoReadBytes: isSet(object.diskIoReadBytes) ? globalThis.Number(object.diskIoReadBytes) : 0,
+      diskIoReadCount: isSet(object.diskIoReadCount) ? globalThis.Number(object.diskIoReadCount) : 0,
+      diskIoWriteBytes: isSet(object.diskIoWriteBytes) ? globalThis.Number(object.diskIoWriteBytes) : 0,
+      diskIoWriteCount: isSet(object.diskIoWriteCount) ? globalThis.Number(object.diskIoWriteCount) : 0,
+      diskIoReadTime: isSet(object.diskIoReadTime) ? globalThis.Number(object.diskIoReadTime) : 0,
+      diskIoWriteTime: isSet(object.diskIoWriteTime) ? globalThis.Number(object.diskIoWriteTime) : 0,
+      diskIoBusyTime: isSet(object.diskIoBusyTime) ? globalThis.Number(object.diskIoBusyTime) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.diskIoReadBytes !== 0) {
+      obj.diskIoReadBytes = Math.round(message.diskIoReadBytes);
+    }
+    if (message.diskIoReadCount !== 0) {
+      obj.diskIoReadCount = Math.round(message.diskIoReadCount);
+    }
+    if (message.diskIoWriteBytes !== 0) {
+      obj.diskIoWriteBytes = Math.round(message.diskIoWriteBytes);
+    }
+    if (message.diskIoWriteCount !== 0) {
+      obj.diskIoWriteCount = Math.round(message.diskIoWriteCount);
+    }
+    if (message.diskIoReadTime !== 0) {
+      obj.diskIoReadTime = Math.round(message.diskIoReadTime);
+    }
+    if (message.diskIoWriteTime !== 0) {
+      obj.diskIoWriteTime = Math.round(message.diskIoWriteTime);
+    }
+    if (message.diskIoBusyTime !== 0) {
+      obj.diskIoBusyTime = Math.round(message.diskIoBusyTime);
+    }
+    return obj;
+  },
+  create(base) {
+    return DiskIOInfo.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseDiskIOInfo();
+    message.diskIoReadBytes = object.diskIoReadBytes ?? 0;
+    message.diskIoReadCount = object.diskIoReadCount ?? 0;
+    message.diskIoWriteBytes = object.diskIoWriteBytes ?? 0;
+    message.diskIoWriteCount = object.diskIoWriteCount ?? 0;
+    message.diskIoReadTime = object.diskIoReadTime ?? 0;
+    message.diskIoWriteTime = object.diskIoWriteTime ?? 0;
+    message.diskIoBusyTime = object.diskIoBusyTime ?? 0;
+    return message;
+  }
+};
+function createBaseNetIOInfo() {
+  return {
+    netIoBytesSent: 0,
+    netIoPacketsSent: 0,
+    netIoBytesRecv: 0,
+    netIoPacketsRecv: 0,
+    netIoDropin: 0,
+    netIoDropout: 0,
+    netIoErrin: 0,
+    netIoErrout: 0
+  };
+}
+var NetIOInfo = {
+  encode(message, writer = new import_wire.BinaryWriter()) {
+    if (message.netIoBytesSent !== 0) {
+      writer.uint32(8).int64(message.netIoBytesSent);
+    }
+    if (message.netIoPacketsSent !== 0) {
+      writer.uint32(16).int64(message.netIoPacketsSent);
+    }
+    if (message.netIoBytesRecv !== 0) {
+      writer.uint32(24).int64(message.netIoBytesRecv);
+    }
+    if (message.netIoPacketsRecv !== 0) {
+      writer.uint32(32).int64(message.netIoPacketsRecv);
+    }
+    if (message.netIoDropin !== 0) {
+      writer.uint32(40).int64(message.netIoDropin);
+    }
+    if (message.netIoDropout !== 0) {
+      writer.uint32(48).int64(message.netIoDropout);
+    }
+    if (message.netIoErrin !== 0) {
+      writer.uint32(56).int64(message.netIoErrin);
+    }
+    if (message.netIoErrout !== 0) {
+      writer.uint32(64).int64(message.netIoErrout);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseNetIOInfo();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+          message.netIoBytesSent = longToNumber(reader.int64());
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.netIoPacketsSent = longToNumber(reader.int64());
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+          message.netIoBytesRecv = longToNumber(reader.int64());
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+          message.netIoPacketsRecv = longToNumber(reader.int64());
+          continue;
+        }
+        case 5: {
+          if (tag !== 40) {
+            break;
+          }
+          message.netIoDropin = longToNumber(reader.int64());
+          continue;
+        }
+        case 6: {
+          if (tag !== 48) {
+            break;
+          }
+          message.netIoDropout = longToNumber(reader.int64());
+          continue;
+        }
+        case 7: {
+          if (tag !== 56) {
+            break;
+          }
+          message.netIoErrin = longToNumber(reader.int64());
+          continue;
+        }
+        case 8: {
+          if (tag !== 64) {
+            break;
+          }
+          message.netIoErrout = longToNumber(reader.int64());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      netIoBytesSent: isSet(object.netIoBytesSent) ? globalThis.Number(object.netIoBytesSent) : 0,
+      netIoPacketsSent: isSet(object.netIoPacketsSent) ? globalThis.Number(object.netIoPacketsSent) : 0,
+      netIoBytesRecv: isSet(object.netIoBytesRecv) ? globalThis.Number(object.netIoBytesRecv) : 0,
+      netIoPacketsRecv: isSet(object.netIoPacketsRecv) ? globalThis.Number(object.netIoPacketsRecv) : 0,
+      netIoDropin: isSet(object.netIoDropin) ? globalThis.Number(object.netIoDropin) : 0,
+      netIoDropout: isSet(object.netIoDropout) ? globalThis.Number(object.netIoDropout) : 0,
+      netIoErrin: isSet(object.netIoErrin) ? globalThis.Number(object.netIoErrin) : 0,
+      netIoErrout: isSet(object.netIoErrout) ? globalThis.Number(object.netIoErrout) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.netIoBytesSent !== 0) {
+      obj.netIoBytesSent = Math.round(message.netIoBytesSent);
+    }
+    if (message.netIoPacketsSent !== 0) {
+      obj.netIoPacketsSent = Math.round(message.netIoPacketsSent);
+    }
+    if (message.netIoBytesRecv !== 0) {
+      obj.netIoBytesRecv = Math.round(message.netIoBytesRecv);
+    }
+    if (message.netIoPacketsRecv !== 0) {
+      obj.netIoPacketsRecv = Math.round(message.netIoPacketsRecv);
+    }
+    if (message.netIoDropin !== 0) {
+      obj.netIoDropin = Math.round(message.netIoDropin);
+    }
+    if (message.netIoDropout !== 0) {
+      obj.netIoDropout = Math.round(message.netIoDropout);
+    }
+    if (message.netIoErrin !== 0) {
+      obj.netIoErrin = Math.round(message.netIoErrin);
+    }
+    if (message.netIoErrout !== 0) {
+      obj.netIoErrout = Math.round(message.netIoErrout);
+    }
+    return obj;
+  },
+  create(base) {
+    return NetIOInfo.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseNetIOInfo();
+    message.netIoBytesSent = object.netIoBytesSent ?? 0;
+    message.netIoPacketsSent = object.netIoPacketsSent ?? 0;
+    message.netIoBytesRecv = object.netIoBytesRecv ?? 0;
+    message.netIoPacketsRecv = object.netIoPacketsRecv ?? 0;
+    message.netIoDropin = object.netIoDropin ?? 0;
+    message.netIoDropout = object.netIoDropout ?? 0;
+    message.netIoErrin = object.netIoErrin ?? 0;
+    message.netIoErrout = object.netIoErrout ?? 0;
+    return message;
+  }
+};
+function createBaseMemInfo() {
+  return {
+    memTotal: 0,
+    memAvailable: 0,
+    memPercent: 0,
+    memUsed: 0,
+    memFree: 0,
+    memActive: 0,
+    memInactive: 0,
+    memBuffers: 0,
+    memCached: 0,
+    memShared: 0,
+    memSlab: 0
+  };
+}
+var MemInfo = {
+  encode(message, writer = new import_wire.BinaryWriter()) {
+    if (message.memTotal !== 0) {
+      writer.uint32(8).int64(message.memTotal);
+    }
+    if (message.memAvailable !== 0) {
+      writer.uint32(16).int64(message.memAvailable);
+    }
+    if (message.memPercent !== 0) {
+      writer.uint32(29).float(message.memPercent);
+    }
+    if (message.memUsed !== 0) {
+      writer.uint32(32).int64(message.memUsed);
+    }
+    if (message.memFree !== 0) {
+      writer.uint32(40).int64(message.memFree);
+    }
+    if (message.memActive !== 0) {
+      writer.uint32(48).int64(message.memActive);
+    }
+    if (message.memInactive !== 0) {
+      writer.uint32(56).int64(message.memInactive);
+    }
+    if (message.memBuffers !== 0) {
+      writer.uint32(64).int64(message.memBuffers);
+    }
+    if (message.memCached !== 0) {
+      writer.uint32(72).int64(message.memCached);
+    }
+    if (message.memShared !== 0) {
+      writer.uint32(80).int64(message.memShared);
+    }
+    if (message.memSlab !== 0) {
+      writer.uint32(88).int64(message.memSlab);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMemInfo();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+          message.memTotal = longToNumber(reader.int64());
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.memAvailable = longToNumber(reader.int64());
+          continue;
+        }
+        case 3: {
+          if (tag !== 29) {
+            break;
+          }
+          message.memPercent = reader.float();
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+          message.memUsed = longToNumber(reader.int64());
+          continue;
+        }
+        case 5: {
+          if (tag !== 40) {
+            break;
+          }
+          message.memFree = longToNumber(reader.int64());
+          continue;
+        }
+        case 6: {
+          if (tag !== 48) {
+            break;
+          }
+          message.memActive = longToNumber(reader.int64());
+          continue;
+        }
+        case 7: {
+          if (tag !== 56) {
+            break;
+          }
+          message.memInactive = longToNumber(reader.int64());
+          continue;
+        }
+        case 8: {
+          if (tag !== 64) {
+            break;
+          }
+          message.memBuffers = longToNumber(reader.int64());
+          continue;
+        }
+        case 9: {
+          if (tag !== 72) {
+            break;
+          }
+          message.memCached = longToNumber(reader.int64());
+          continue;
+        }
+        case 10: {
+          if (tag !== 80) {
+            break;
+          }
+          message.memShared = longToNumber(reader.int64());
+          continue;
+        }
+        case 11: {
+          if (tag !== 88) {
+            break;
+          }
+          message.memSlab = longToNumber(reader.int64());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      memTotal: isSet(object.memTotal) ? globalThis.Number(object.memTotal) : 0,
+      memAvailable: isSet(object.memAvailable) ? globalThis.Number(object.memAvailable) : 0,
+      memPercent: isSet(object.memPercent) ? globalThis.Number(object.memPercent) : 0,
+      memUsed: isSet(object.memUsed) ? globalThis.Number(object.memUsed) : 0,
+      memFree: isSet(object.memFree) ? globalThis.Number(object.memFree) : 0,
+      memActive: isSet(object.memActive) ? globalThis.Number(object.memActive) : 0,
+      memInactive: isSet(object.memInactive) ? globalThis.Number(object.memInactive) : 0,
+      memBuffers: isSet(object.memBuffers) ? globalThis.Number(object.memBuffers) : 0,
+      memCached: isSet(object.memCached) ? globalThis.Number(object.memCached) : 0,
+      memShared: isSet(object.memShared) ? globalThis.Number(object.memShared) : 0,
+      memSlab: isSet(object.memSlab) ? globalThis.Number(object.memSlab) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.memTotal !== 0) {
+      obj.memTotal = Math.round(message.memTotal);
+    }
+    if (message.memAvailable !== 0) {
+      obj.memAvailable = Math.round(message.memAvailable);
+    }
+    if (message.memPercent !== 0) {
+      obj.memPercent = message.memPercent;
+    }
+    if (message.memUsed !== 0) {
+      obj.memUsed = Math.round(message.memUsed);
+    }
+    if (message.memFree !== 0) {
+      obj.memFree = Math.round(message.memFree);
+    }
+    if (message.memActive !== 0) {
+      obj.memActive = Math.round(message.memActive);
+    }
+    if (message.memInactive !== 0) {
+      obj.memInactive = Math.round(message.memInactive);
+    }
+    if (message.memBuffers !== 0) {
+      obj.memBuffers = Math.round(message.memBuffers);
+    }
+    if (message.memCached !== 0) {
+      obj.memCached = Math.round(message.memCached);
+    }
+    if (message.memShared !== 0) {
+      obj.memShared = Math.round(message.memShared);
+    }
+    if (message.memSlab !== 0) {
+      obj.memSlab = Math.round(message.memSlab);
+    }
+    return obj;
+  },
+  create(base) {
+    return MemInfo.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMemInfo();
+    message.memTotal = object.memTotal ?? 0;
+    message.memAvailable = object.memAvailable ?? 0;
+    message.memPercent = object.memPercent ?? 0;
+    message.memUsed = object.memUsed ?? 0;
+    message.memFree = object.memFree ?? 0;
+    message.memActive = object.memActive ?? 0;
+    message.memInactive = object.memInactive ?? 0;
+    message.memBuffers = object.memBuffers ?? 0;
+    message.memCached = object.memCached ?? 0;
+    message.memShared = object.memShared ?? 0;
+    message.memSlab = object.memSlab ?? 0;
+    return message;
+  }
+};
+function longToNumber(int64) {
+  const num = globalThis.Number(int64.toString());
+  if (num > globalThis.Number.MAX_SAFE_INTEGER) {
+    throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+  }
+  if (num < globalThis.Number.MIN_SAFE_INTEGER) {
+    throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
+  }
+  return num;
+}
+function isSet(value) {
+  return value !== null && value !== void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BatteryInfo,
+  CpuInfo,
+  DiskIOInfo,
+  DiskUsage,
+  MemInfo,
+  NetIOInfo,
+  protobufPackage
+});