@m1kad0/hannah-proto 4.8.0 → 5.1.0

package/dist/v2/device_model.js

@@ -0,0 +1,777 @@
+"use strict";
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.12.1
+//   protoc               unknown
+// source: hannah/v2/device_model.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetSlot = exports.DeviceAvailability = exports.SlotUpdate = exports.TypedDeviceSnapshot = exports.TypedDevice = exports.Slot = exports.SlotValue = exports.SlotKind = exports.DeviceSubtype = exports.DeviceClass = exports.protobufPackage = void 0;
+/* eslint-disable */
+const wire_1 = require("@bufbuild/protobuf/wire");
+exports.protobufPackage = "hannah.v2";
+/**
+ * What kind of device this is. A class exists per family of verbs, not per feature:
+ * a measuring socket is a SOCKET with a filled POWER slot, not a class of its own.
+ */
+var DeviceClass;
+(function (DeviceClass) {
+    DeviceClass[DeviceClass["DEVICE_CLASS_UNSPECIFIED"] = 0] = "DEVICE_CLASS_UNSPECIFIED";
+    /** DEVICE_CLASS_LIGHT - Switchable light. Slots: ON (required), BRIGHTNESS, COLOR, COLOR_TEMPERATURE. */
+    DeviceClass[DeviceClass["DEVICE_CLASS_LIGHT"] = 1] = "DEVICE_CLASS_LIGHT";
+    /** DEVICE_CLASS_SOCKET - Socket/plug. Slots: ON (required), POWER, ENERGY, VOLTAGE, CURRENT. */
+    DeviceClass[DeviceClass["DEVICE_CLASS_SOCKET"] = 2] = "DEVICE_CLASS_SOCKET";
+    /**
+     * DEVICE_CLASS_GENERIC_BINARY_SWITCH - Any other switchable boolean that fits no other class (scene-like switches,
+     * flags, vendor specific switches). Slots: ON (required).
+     */
+    DeviceClass[DeviceClass["DEVICE_CLASS_GENERIC_BINARY_SWITCH"] = 3] = "DEVICE_CLASS_GENERIC_BINARY_SWITCH";
+    /**
+     * DEVICE_CLASS_THERMOSTAT - Radiator or room thermostat. Slots: TARGET_TEMPERATURE (required), TEMPERATURE,
+     * HUMIDITY, VALVE. Comfort/eco setpoints and similar are not slots. Units with an
+     * operating mode and a fan are DEVICE_CLASS_CLIMATE.
+     */
+    DeviceClass[DeviceClass["DEVICE_CLASS_THERMOSTAT"] = 4] = "DEVICE_CLASS_THERMOSTAT";
+    /** DEVICE_CLASS_COVER - Blind, shutter, awning. Slots: POSITION (required), TILT, STOP. */
+    DeviceClass[DeviceClass["DEVICE_CLASS_COVER"] = 5] = "DEVICE_CLASS_COVER";
+    /**
+     * DEVICE_CLASS_SENSOR - Read-only measurements. At least one measurement slot: TEMPERATURE, HUMIDITY,
+     * ILLUMINANCE, PRESSURE, CO2, IAQ, VOC, POWER, ENERGY, MOTION.
+     */
+    DeviceClass[DeviceClass["DEVICE_CLASS_SENSOR"] = 6] = "DEVICE_CLASS_SENSOR";
+    /** DEVICE_CLASS_CONTACT - Door or window contact. Slots: OPEN (required, read-only). */
+    DeviceClass[DeviceClass["DEVICE_CLASS_CONTACT"] = 7] = "DEVICE_CLASS_CONTACT";
+    /**
+     * DEVICE_CLASS_GENERIC - Fallback for anything that matches no class: a list of typed values
+     * (GENERIC_NUMBER / GENERIC_BOOL / GENERIC_TEXT), each with label and unit.
+     */
+    DeviceClass[DeviceClass["DEVICE_CLASS_GENERIC"] = 8] = "DEVICE_CLASS_GENERIC";
+    /**
+     * DEVICE_CLASS_CLIMATE - Air conditioner / room climate unit with operating mode and fan. Slots: ON (required),
+     * MODE, TARGET_TEMPERATURE, TEMPERATURE, HUMIDITY, FAN_SPEED. A radiator thermostat
+     * without mode and fan is a THERMOSTAT, not a CLIMATE.
+     */
+    DeviceClass[DeviceClass["DEVICE_CLASS_CLIMATE"] = 9] = "DEVICE_CLASS_CLIMATE";
+    DeviceClass[DeviceClass["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(DeviceClass || (exports.DeviceClass = DeviceClass = {}));
+/**
+ * A finer kind within a device class, for the cases where the class alone does not say
+ * what a user means ("the windows" versus "the doors"). Optional: the adapter sets it
+ * where it knows (function, role, type detector), otherwise UNSPECIFIED.
+ */
+var DeviceSubtype;
+(function (DeviceSubtype) {
+    /** DEVICE_SUBTYPE_UNSPECIFIED - No statement. Hannah Core may fall back to the device name. */
+    DeviceSubtype[DeviceSubtype["DEVICE_SUBTYPE_UNSPECIFIED"] = 0] = "DEVICE_SUBTYPE_UNSPECIFIED";
+    /** DEVICE_SUBTYPE_WINDOW - DEVICE_CLASS_CONTACT: window contact. */
+    DeviceSubtype[DeviceSubtype["DEVICE_SUBTYPE_WINDOW"] = 1] = "DEVICE_SUBTYPE_WINDOW";
+    /** DEVICE_SUBTYPE_DOOR - DEVICE_CLASS_CONTACT: door contact. */
+    DeviceSubtype[DeviceSubtype["DEVICE_SUBTYPE_DOOR"] = 2] = "DEVICE_SUBTYPE_DOOR";
+    DeviceSubtype[DeviceSubtype["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(DeviceSubtype || (exports.DeviceSubtype = DeviceSubtype = {}));
+/**
+ * What a slot means, and therefore which scale and unit its value has. The adapter
+ * normalizes every value to exactly this scale; Core relies on it.
+ */
+var SlotKind;
+(function (SlotKind) {
+    SlotKind[SlotKind["SLOT_KIND_UNSPECIFIED"] = 0] = "SLOT_KIND_UNSPECIFIED";
+    /** SLOT_KIND_ON - --- switching and light --- */
+    SlotKind[SlotKind["SLOT_KIND_ON"] = 1] = "SLOT_KIND_ON";
+    /** SLOT_KIND_BRIGHTNESS - number, 0-100 (%) */
+    SlotKind[SlotKind["SLOT_KIND_BRIGHTNESS"] = 2] = "SLOT_KIND_BRIGHTNESS";
+    /** SLOT_KIND_COLOR - rgb, 0xRRGGBB */
+    SlotKind[SlotKind["SLOT_KIND_COLOR"] = 3] = "SLOT_KIND_COLOR";
+    /** SLOT_KIND_COLOR_TEMPERATURE - number, Kelvin (e.g. 2700 warm white, 6500 cold white) */
+    SlotKind[SlotKind["SLOT_KIND_COLOR_TEMPERATURE"] = 4] = "SLOT_KIND_COLOR_TEMPERATURE";
+    /** SLOT_KIND_POWER - --- electricity --- */
+    SlotKind[SlotKind["SLOT_KIND_POWER"] = 10] = "SLOT_KIND_POWER";
+    /** SLOT_KIND_ENERGY - number, kWh (cumulative) */
+    SlotKind[SlotKind["SLOT_KIND_ENERGY"] = 11] = "SLOT_KIND_ENERGY";
+    /** SLOT_KIND_VOLTAGE - number, V */
+    SlotKind[SlotKind["SLOT_KIND_VOLTAGE"] = 12] = "SLOT_KIND_VOLTAGE";
+    /** SLOT_KIND_CURRENT - number, A */
+    SlotKind[SlotKind["SLOT_KIND_CURRENT"] = 13] = "SLOT_KIND_CURRENT";
+    /** SLOT_KIND_TARGET_TEMPERATURE - --- climate --- */
+    SlotKind[SlotKind["SLOT_KIND_TARGET_TEMPERATURE"] = 20] = "SLOT_KIND_TARGET_TEMPERATURE";
+    /** SLOT_KIND_TEMPERATURE - number, °C, measured value */
+    SlotKind[SlotKind["SLOT_KIND_TEMPERATURE"] = 21] = "SLOT_KIND_TEMPERATURE";
+    /** SLOT_KIND_HUMIDITY - number, 0-100 (% relative) */
+    SlotKind[SlotKind["SLOT_KIND_HUMIDITY"] = 22] = "SLOT_KIND_HUMIDITY";
+    /** SLOT_KIND_VALVE - number, 0-100 (% open) */
+    SlotKind[SlotKind["SLOT_KIND_VALVE"] = 23] = "SLOT_KIND_VALVE";
+    /**
+     * SLOT_KIND_MODE - Operating mode of a CLIMATE device, text, one of: "cool", "heat", "dry", "fan_only",
+     * "auto". The adapter normalizes the device's own values to this vocabulary. The modes the
+     * device really supports are listed in Slot.options.
+     */
+    SlotKind[SlotKind["SLOT_KIND_MODE"] = 24] = "SLOT_KIND_MODE";
+    /**
+     * SLOT_KIND_FAN_SPEED - Fan level of a CLIMATE device, text, one of: "low", "medium", "high", "auto". Supported
+     * levels are listed in Slot.options.
+     */
+    SlotKind[SlotKind["SLOT_KIND_FAN_SPEED"] = 25] = "SLOT_KIND_FAN_SPEED";
+    /** SLOT_KIND_POSITION - --- cover --- */
+    SlotKind[SlotKind["SLOT_KIND_POSITION"] = 30] = "SLOT_KIND_POSITION";
+    /** SLOT_KIND_TILT - number, 0-100 (%) */
+    SlotKind[SlotKind["SLOT_KIND_TILT"] = 31] = "SLOT_KIND_TILT";
+    /** SLOT_KIND_STOP - boolean trigger: true = stop movement, not a state */
+    SlotKind[SlotKind["SLOT_KIND_STOP"] = 32] = "SLOT_KIND_STOP";
+    /** SLOT_KIND_OPEN - --- binary sensors --- */
+    SlotKind[SlotKind["SLOT_KIND_OPEN"] = 40] = "SLOT_KIND_OPEN";
+    /** SLOT_KIND_MOTION - boolean: true = motion/presence detected */
+    SlotKind[SlotKind["SLOT_KIND_MOTION"] = 41] = "SLOT_KIND_MOTION";
+    /** SLOT_KIND_ILLUMINANCE - --- further measurements --- */
+    SlotKind[SlotKind["SLOT_KIND_ILLUMINANCE"] = 50] = "SLOT_KIND_ILLUMINANCE";
+    /** SLOT_KIND_PRESSURE - number, hPa */
+    SlotKind[SlotKind["SLOT_KIND_PRESSURE"] = 51] = "SLOT_KIND_PRESSURE";
+    /** SLOT_KIND_CO2 - number, ppm */
+    SlotKind[SlotKind["SLOT_KIND_CO2"] = 52] = "SLOT_KIND_CO2";
+    /** SLOT_KIND_IAQ - number, index 0-500 */
+    SlotKind[SlotKind["SLOT_KIND_IAQ"] = 53] = "SLOT_KIND_IAQ";
+    /** SLOT_KIND_VOC - number, ppm */
+    SlotKind[SlotKind["SLOT_KIND_VOC"] = 54] = "SLOT_KIND_VOC";
+    /** SLOT_KIND_GENERIC_NUMBER - --- generic values (DEVICE_CLASS_GENERIC), described by label and unit --- */
+    SlotKind[SlotKind["SLOT_KIND_GENERIC_NUMBER"] = 90] = "SLOT_KIND_GENERIC_NUMBER";
+    SlotKind[SlotKind["SLOT_KIND_GENERIC_BOOL"] = 91] = "SLOT_KIND_GENERIC_BOOL";
+    SlotKind[SlotKind["SLOT_KIND_GENERIC_TEXT"] = 92] = "SLOT_KIND_GENERIC_TEXT";
+    SlotKind[SlotKind["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(SlotKind || (exports.SlotKind = SlotKind = {}));
+function createBaseSlotValue() {
+    return { boolean: undefined, number: undefined, text: undefined, rgb: undefined };
+}
+exports.SlotValue = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.boolean !== undefined) {
+            writer.uint32(8).bool(message.boolean);
+        }
+        if (message.number !== undefined) {
+            writer.uint32(17).double(message.number);
+        }
+        if (message.text !== undefined) {
+            writer.uint32(26).string(message.text);
+        }
+        if (message.rgb !== undefined) {
+            writer.uint32(32).uint32(message.rgb);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseSlotValue();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 8) {
+                            break;
+                        }
+                        message.boolean = reader.bool();
+                        continue;
+                    }
+                    case 2: {
+                        if (tag !== 17) {
+                            break;
+                        }
+                        message.number = reader.double();
+                        continue;
+                    }
+                    case 3: {
+                        if (tag !== 26) {
+                            break;
+                        }
+                        message.text = reader.string();
+                        continue;
+                    }
+                    case 4: {
+                        if (tag !== 32) {
+                            break;
+                        }
+                        message.rgb = reader.uint32();
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    create(base) {
+        return exports.SlotValue.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseSlotValue();
+        message.boolean = object.boolean ?? undefined;
+        message.number = object.number ?? undefined;
+        message.text = object.text ?? undefined;
+        message.rgb = object.rgb ?? undefined;
+        return message;
+    },
+};
+function createBaseSlot() {
+    return {
+        slotId: "",
+        kind: 0,
+        value: undefined,
+        writable: false,
+        unit: "",
+        label: "",
+        requiredTrustLevel: undefined,
+        options: [],
+    };
+}
+exports.Slot = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.slotId !== "") {
+            writer.uint32(10).string(message.slotId);
+        }
+        if (message.kind !== 0) {
+            writer.uint32(16).int32(message.kind);
+        }
+        if (message.value !== undefined) {
+            exports.SlotValue.encode(message.value, writer.uint32(26).fork()).join();
+        }
+        if (message.writable !== false) {
+            writer.uint32(32).bool(message.writable);
+        }
+        if (message.unit !== "") {
+            writer.uint32(42).string(message.unit);
+        }
+        if (message.label !== "") {
+            writer.uint32(50).string(message.label);
+        }
+        if (message.requiredTrustLevel !== undefined) {
+            writer.uint32(56).int32(message.requiredTrustLevel);
+        }
+        for (const v of message.options) {
+            writer.uint32(66).string(v);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseSlot();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 10) {
+                            break;
+                        }
+                        message.slotId = reader.string();
+                        continue;
+                    }
+                    case 2: {
+                        if (tag !== 16) {
+                            break;
+                        }
+                        message.kind = reader.int32();
+                        continue;
+                    }
+                    case 3: {
+                        if (tag !== 26) {
+                            break;
+                        }
+                        message.value = exports.SlotValue.decode(reader, reader.uint32());
+                        continue;
+                    }
+                    case 4: {
+                        if (tag !== 32) {
+                            break;
+                        }
+                        message.writable = reader.bool();
+                        continue;
+                    }
+                    case 5: {
+                        if (tag !== 42) {
+                            break;
+                        }
+                        message.unit = reader.string();
+                        continue;
+                    }
+                    case 6: {
+                        if (tag !== 50) {
+                            break;
+                        }
+                        message.label = reader.string();
+                        continue;
+                    }
+                    case 7: {
+                        if (tag !== 56) {
+                            break;
+                        }
+                        message.requiredTrustLevel = reader.int32();
+                        continue;
+                    }
+                    case 8: {
+                        if (tag !== 66) {
+                            break;
+                        }
+                        message.options.push(reader.string());
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    create(base) {
+        return exports.Slot.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseSlot();
+        message.slotId = object.slotId ?? "";
+        message.kind = object.kind ?? 0;
+        message.value = (object.value !== undefined && object.value !== null)
+            ? exports.SlotValue.fromPartial(object.value)
+            : undefined;
+        message.writable = object.writable ?? false;
+        message.unit = object.unit ?? "";
+        message.label = object.label ?? "";
+        message.requiredTrustLevel = object.requiredTrustLevel ?? undefined;
+        message.options = object.options?.map((e) => e) || [];
+        return message;
+    },
+};
+function createBaseTypedDevice() {
+    return { deviceId: "", name: "", room: "", floor: "", deviceClass: 0, slots: [], available: false, subtype: 0 };
+}
+exports.TypedDevice = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.deviceId !== "") {
+            writer.uint32(10).string(message.deviceId);
+        }
+        if (message.name !== "") {
+            writer.uint32(18).string(message.name);
+        }
+        if (message.room !== "") {
+            writer.uint32(26).string(message.room);
+        }
+        if (message.floor !== "") {
+            writer.uint32(34).string(message.floor);
+        }
+        if (message.deviceClass !== 0) {
+            writer.uint32(40).int32(message.deviceClass);
+        }
+        for (const v of message.slots) {
+            exports.Slot.encode(v, writer.uint32(50).fork()).join();
+        }
+        if (message.available !== false) {
+            writer.uint32(56).bool(message.available);
+        }
+        if (message.subtype !== 0) {
+            writer.uint32(64).int32(message.subtype);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseTypedDevice();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 10) {
+                            break;
+                        }
+                        message.deviceId = reader.string();
+                        continue;
+                    }
+                    case 2: {
+                        if (tag !== 18) {
+                            break;
+                        }
+                        message.name = reader.string();
+                        continue;
+                    }
+                    case 3: {
+                        if (tag !== 26) {
+                            break;
+                        }
+                        message.room = reader.string();
+                        continue;
+                    }
+                    case 4: {
+                        if (tag !== 34) {
+                            break;
+                        }
+                        message.floor = reader.string();
+                        continue;
+                    }
+                    case 5: {
+                        if (tag !== 40) {
+                            break;
+                        }
+                        message.deviceClass = reader.int32();
+                        continue;
+                    }
+                    case 6: {
+                        if (tag !== 50) {
+                            break;
+                        }
+                        message.slots.push(exports.Slot.decode(reader, reader.uint32()));
+                        continue;
+                    }
+                    case 7: {
+                        if (tag !== 56) {
+                            break;
+                        }
+                        message.available = reader.bool();
+                        continue;
+                    }
+                    case 8: {
+                        if (tag !== 64) {
+                            break;
+                        }
+                        message.subtype = reader.int32();
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    create(base) {
+        return exports.TypedDevice.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseTypedDevice();
+        message.deviceId = object.deviceId ?? "";
+        message.name = object.name ?? "";
+        message.room = object.room ?? "";
+        message.floor = object.floor ?? "";
+        message.deviceClass = object.deviceClass ?? 0;
+        message.slots = object.slots?.map((e) => exports.Slot.fromPartial(e)) || [];
+        message.available = object.available ?? false;
+        message.subtype = object.subtype ?? 0;
+        return message;
+    },
+};
+function createBaseTypedDeviceSnapshot() {
+    return { devices: [] };
+}
+exports.TypedDeviceSnapshot = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        for (const v of message.devices) {
+            exports.TypedDevice.encode(v, writer.uint32(10).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseTypedDeviceSnapshot();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 10) {
+                            break;
+                        }
+                        message.devices.push(exports.TypedDevice.decode(reader, reader.uint32()));
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    create(base) {
+        return exports.TypedDeviceSnapshot.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseTypedDeviceSnapshot();
+        message.devices = object.devices?.map((e) => exports.TypedDevice.fromPartial(e)) || [];
+        return message;
+    },
+};
+function createBaseSlotUpdate() {
+    return { deviceId: "", slotId: "", value: undefined, ack: false, ts: 0n };
+}
+exports.SlotUpdate = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.deviceId !== "") {
+            writer.uint32(10).string(message.deviceId);
+        }
+        if (message.slotId !== "") {
+            writer.uint32(18).string(message.slotId);
+        }
+        if (message.value !== undefined) {
+            exports.SlotValue.encode(message.value, writer.uint32(26).fork()).join();
+        }
+        if (message.ack !== false) {
+            writer.uint32(32).bool(message.ack);
+        }
+        if (message.ts !== 0n) {
+            if (BigInt.asIntN(64, message.ts) !== message.ts) {
+                throw new globalThis.Error("value provided for field message.ts of type int64 too large");
+            }
+            writer.uint32(40).int64(message.ts);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseSlotUpdate();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 10) {
+                            break;
+                        }
+                        message.deviceId = reader.string();
+                        continue;
+                    }
+                    case 2: {
+                        if (tag !== 18) {
+                            break;
+                        }
+                        message.slotId = reader.string();
+                        continue;
+                    }
+                    case 3: {
+                        if (tag !== 26) {
+                            break;
+                        }
+                        message.value = exports.SlotValue.decode(reader, reader.uint32());
+                        continue;
+                    }
+                    case 4: {
+                        if (tag !== 32) {
+                            break;
+                        }
+                        message.ack = reader.bool();
+                        continue;
+                    }
+                    case 5: {
+                        if (tag !== 40) {
+                            break;
+                        }
+                        message.ts = reader.int64();
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    create(base) {
+        return exports.SlotUpdate.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseSlotUpdate();
+        message.deviceId = object.deviceId ?? "";
+        message.slotId = object.slotId ?? "";
+        message.value = (object.value !== undefined && object.value !== null)
+            ? exports.SlotValue.fromPartial(object.value)
+            : undefined;
+        message.ack = object.ack ?? false;
+        message.ts = (object.ts !== undefined && object.ts !== null) ? BigInt(object.ts) : 0n;
+        return message;
+    },
+};
+function createBaseDeviceAvailability() {
+    return { deviceId: "", available: false };
+}
+exports.DeviceAvailability = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.deviceId !== "") {
+            writer.uint32(10).string(message.deviceId);
+        }
+        if (message.available !== false) {
+            writer.uint32(16).bool(message.available);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseDeviceAvailability();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 10) {
+                            break;
+                        }
+                        message.deviceId = reader.string();
+                        continue;
+                    }
+                    case 2: {
+                        if (tag !== 16) {
+                            break;
+                        }
+                        message.available = reader.bool();
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    create(base) {
+        return exports.DeviceAvailability.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseDeviceAvailability();
+        message.deviceId = object.deviceId ?? "";
+        message.available = object.available ?? false;
+        return message;
+    },
+};
+function createBaseSetSlot() {
+    return { deviceId: "", slotId: "", value: undefined };
+}
+exports.SetSlot = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.deviceId !== "") {
+            writer.uint32(10).string(message.deviceId);
+        }
+        if (message.slotId !== "") {
+            writer.uint32(18).string(message.slotId);
+        }
+        if (message.value !== undefined) {
+            exports.SlotValue.encode(message.value, writer.uint32(26).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseSetSlot();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 10) {
+                            break;
+                        }
+                        message.deviceId = reader.string();
+                        continue;
+                    }
+                    case 2: {
+                        if (tag !== 18) {
+                            break;
+                        }
+                        message.slotId = reader.string();
+                        continue;
+                    }
+                    case 3: {
+                        if (tag !== 26) {
+                            break;
+                        }
+                        message.value = exports.SlotValue.decode(reader, reader.uint32());
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    create(base) {
+        return exports.SetSlot.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseSetSlot();
+        message.deviceId = object.deviceId ?? "";
+        message.slotId = object.slotId ?? "";
+        message.value = (object.value !== undefined && object.value !== null)
+            ? exports.SlotValue.fromPartial(object.value)
+            : undefined;
+        return message;
+    },
+};