@ekhein/lamda-node-sdk 1.0.3 → 2.0.0

package/dist/src/rpc/status.js

@@ -0,0 +1,896 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+export const protobufPackage = "lamda.rpc";
+function createBaseBatteryInfo() {
+    return { battCharging: false, battPercent: 0, battTemperature: 0 };
+}
+export const BatteryInfo = {
+    encode(message, writer = new 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 BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? 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,
+    };
+}
+export const CpuInfo = {
+    encode(message, writer = new 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 BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? 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 };
+}
+export const DiskUsage = {
+    encode(message, writer = new 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 BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? 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,
+    };
+}
+export const DiskIOInfo = {
+    encode(message, writer = new 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 BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? 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,
+    };
+}
+export const NetIOInfo = {
+    encode(message, writer = new 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 BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? 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,
+    };
+}
+export const MemInfo = {
+    encode(message, writer = new 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 BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? 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 !== undefined;
+}