@teslemetry/tesla-protocol 0.5.0 → 1.0.0

package/dist/energy_device/neurio_meter_api.cjs

@@ -0,0 +1,1437 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_energy_device_networking = require("./networking.cjs");
+let _bufbuild_protobuf_wire = require("@bufbuild/protobuf/wire");
+//#region src/energy_device/neurio_meter_api.ts
+const protobufPackage = "tesla.proto.energy_device.v1";
+let PowerType = /* @__PURE__ */ function(PowerType) {
+	PowerType[PowerType["POWER_TYPE_INVALID"] = 0] = "POWER_TYPE_INVALID";
+	PowerType[PowerType["POWER_TYPE_AC_1_PHASE"] = 1] = "POWER_TYPE_AC_1_PHASE";
+	PowerType[PowerType["POWER_TYPE_AC_3_PHASE"] = 2] = "POWER_TYPE_AC_3_PHASE";
+	PowerType[PowerType["POWER_TYPE_DC"] = 3] = "POWER_TYPE_DC";
+	PowerType[PowerType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+	return PowerType;
+}({});
+function powerTypeFromJSON(object) {
+	switch (object) {
+		case 0:
+		case "POWER_TYPE_INVALID": return 0;
+		case 1:
+		case "POWER_TYPE_AC_1_PHASE": return 1;
+		case 2:
+		case "POWER_TYPE_AC_3_PHASE": return 2;
+		case 3:
+		case "POWER_TYPE_DC": return 3;
+		default: return -1;
+	}
+}
+function powerTypeToJSON(object) {
+	switch (object) {
+		case 0: return "POWER_TYPE_INVALID";
+		case 1: return "POWER_TYPE_AC_1_PHASE";
+		case 2: return "POWER_TYPE_AC_3_PHASE";
+		case 3: return "POWER_TYPE_DC";
+		default: return "UNRECOGNIZED";
+	}
+}
+let ConnectorType = /* @__PURE__ */ function(ConnectorType) {
+	ConnectorType[ConnectorType["CONNECTOR_TYPE_INVALID"] = 0] = "CONNECTOR_TYPE_INVALID";
+	ConnectorType[ConnectorType["CONNECTOR_TYPE_CCS1"] = 1] = "CONNECTOR_TYPE_CCS1";
+	ConnectorType[ConnectorType["CONNECTOR_TYPE_CCS2"] = 2] = "CONNECTOR_TYPE_CCS2";
+	ConnectorType[ConnectorType["CONNECTOR_TYPE_GB"] = 3] = "CONNECTOR_TYPE_GB";
+	ConnectorType[ConnectorType["CONNECTOR_TYPE_NA"] = 4] = "CONNECTOR_TYPE_NA";
+	ConnectorType[ConnectorType["CONNECTOR_TYPE_TYPE_2"] = 5] = "CONNECTOR_TYPE_TYPE_2";
+	ConnectorType[ConnectorType["CONNECTOR_TYPE_J1772"] = 6] = "CONNECTOR_TYPE_J1772";
+	ConnectorType[ConnectorType["CONNECTOR_TYPE_INDISTINGUISHABLE_DUAL_HANDLE"] = 7] = "CONNECTOR_TYPE_INDISTINGUISHABLE_DUAL_HANDLE";
+	ConnectorType[ConnectorType["CONNECTOR_TYPE_UNKNOWN"] = 8] = "CONNECTOR_TYPE_UNKNOWN";
+	ConnectorType[ConnectorType["CONNECTOR_TYPE_MCS"] = 9] = "CONNECTOR_TYPE_MCS";
+	ConnectorType[ConnectorType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+	return ConnectorType;
+}({});
+function connectorTypeFromJSON(object) {
+	switch (object) {
+		case 0:
+		case "CONNECTOR_TYPE_INVALID": return 0;
+		case 1:
+		case "CONNECTOR_TYPE_CCS1": return 1;
+		case 2:
+		case "CONNECTOR_TYPE_CCS2": return 2;
+		case 3:
+		case "CONNECTOR_TYPE_GB": return 3;
+		case 4:
+		case "CONNECTOR_TYPE_NA": return 4;
+		case 5:
+		case "CONNECTOR_TYPE_TYPE_2": return 5;
+		case 6:
+		case "CONNECTOR_TYPE_J1772": return 6;
+		case 7:
+		case "CONNECTOR_TYPE_INDISTINGUISHABLE_DUAL_HANDLE": return 7;
+		case 8:
+		case "CONNECTOR_TYPE_UNKNOWN": return 8;
+		case 9:
+		case "CONNECTOR_TYPE_MCS": return 9;
+		default: return -1;
+	}
+}
+function connectorTypeToJSON(object) {
+	switch (object) {
+		case 0: return "CONNECTOR_TYPE_INVALID";
+		case 1: return "CONNECTOR_TYPE_CCS1";
+		case 2: return "CONNECTOR_TYPE_CCS2";
+		case 3: return "CONNECTOR_TYPE_GB";
+		case 4: return "CONNECTOR_TYPE_NA";
+		case 5: return "CONNECTOR_TYPE_TYPE_2";
+		case 6: return "CONNECTOR_TYPE_J1772";
+		case 7: return "CONNECTOR_TYPE_INDISTINGUISHABLE_DUAL_HANDLE";
+		case 8: return "CONNECTOR_TYPE_UNKNOWN";
+		case 9: return "CONNECTOR_TYPE_MCS";
+		default: return "UNRECOGNIZED";
+	}
+}
+let NeurioConnectionStatus = /* @__PURE__ */ function(NeurioConnectionStatus) {
+	NeurioConnectionStatus[NeurioConnectionStatus["NEURIO_CONNECTION_STATUS_INVALID"] = 0] = "NEURIO_CONNECTION_STATUS_INVALID";
+	NeurioConnectionStatus[NeurioConnectionStatus["NEURIO_CONNECTION_STATUS_NO_COMMS"] = 1] = "NEURIO_CONNECTION_STATUS_NO_COMMS";
+	NeurioConnectionStatus[NeurioConnectionStatus["NEURIO_CONNECTION_STATUS_PAIRING"] = 2] = "NEURIO_CONNECTION_STATUS_PAIRING";
+	NeurioConnectionStatus[NeurioConnectionStatus["NEURIO_CONNECTION_STATUS_CONNECTED"] = 3] = "NEURIO_CONNECTION_STATUS_CONNECTED";
+	NeurioConnectionStatus[NeurioConnectionStatus["NEURIO_CONNECTION_STATUS_CONFIG_CHANGE_UNDERWAY"] = 4] = "NEURIO_CONNECTION_STATUS_CONFIG_CHANGE_UNDERWAY";
+	NeurioConnectionStatus[NeurioConnectionStatus["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+	return NeurioConnectionStatus;
+}({});
+function neurioConnectionStatusFromJSON(object) {
+	switch (object) {
+		case 0:
+		case "NEURIO_CONNECTION_STATUS_INVALID": return 0;
+		case 1:
+		case "NEURIO_CONNECTION_STATUS_NO_COMMS": return 1;
+		case 2:
+		case "NEURIO_CONNECTION_STATUS_PAIRING": return 2;
+		case 3:
+		case "NEURIO_CONNECTION_STATUS_CONNECTED": return 3;
+		case 4:
+		case "NEURIO_CONNECTION_STATUS_CONFIG_CHANGE_UNDERWAY": return 4;
+		default: return -1;
+	}
+}
+function neurioConnectionStatusToJSON(object) {
+	switch (object) {
+		case 0: return "NEURIO_CONNECTION_STATUS_INVALID";
+		case 1: return "NEURIO_CONNECTION_STATUS_NO_COMMS";
+		case 2: return "NEURIO_CONNECTION_STATUS_PAIRING";
+		case 3: return "NEURIO_CONNECTION_STATUS_CONNECTED";
+		case 4: return "NEURIO_CONNECTION_STATUS_CONFIG_CHANGE_UNDERWAY";
+		default: return "UNRECOGNIZED";
+	}
+}
+let NeurioConnectionError = /* @__PURE__ */ function(NeurioConnectionError) {
+	NeurioConnectionError[NeurioConnectionError["NEURIO_CONNECTION_ERROR_INVALID"] = 0] = "NEURIO_CONNECTION_ERROR_INVALID";
+	NeurioConnectionError[NeurioConnectionError["NEURIO_CONNECTION_ERROR_NONE"] = 1] = "NEURIO_CONNECTION_ERROR_NONE";
+	NeurioConnectionError[NeurioConnectionError["NEURIO_CONNECTION_ERROR_UNKNOWN"] = 2] = "NEURIO_CONNECTION_ERROR_UNKNOWN";
+	NeurioConnectionError[NeurioConnectionError["NEURIO_CONNECTION_ERROR_WIFI_AP"] = 3] = "NEURIO_CONNECTION_ERROR_WIFI_AP";
+	NeurioConnectionError[NeurioConnectionError["NEURIO_CONNECTION_ERROR_PAIRING_COMMAND"] = 4] = "NEURIO_CONNECTION_ERROR_PAIRING_COMMAND";
+	NeurioConnectionError[NeurioConnectionError["NEURIO_CONNECTION_ERROR_REBOOT_COMMAND"] = 5] = "NEURIO_CONNECTION_ERROR_REBOOT_COMMAND";
+	NeurioConnectionError[NeurioConnectionError["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+	return NeurioConnectionError;
+}({});
+function neurioConnectionErrorFromJSON(object) {
+	switch (object) {
+		case 0:
+		case "NEURIO_CONNECTION_ERROR_INVALID": return 0;
+		case 1:
+		case "NEURIO_CONNECTION_ERROR_NONE": return 1;
+		case 2:
+		case "NEURIO_CONNECTION_ERROR_UNKNOWN": return 2;
+		case 3:
+		case "NEURIO_CONNECTION_ERROR_WIFI_AP": return 3;
+		case 4:
+		case "NEURIO_CONNECTION_ERROR_PAIRING_COMMAND": return 4;
+		case 5:
+		case "NEURIO_CONNECTION_ERROR_REBOOT_COMMAND": return 5;
+		default: return -1;
+	}
+}
+function neurioConnectionErrorToJSON(object) {
+	switch (object) {
+		case 0: return "NEURIO_CONNECTION_ERROR_INVALID";
+		case 1: return "NEURIO_CONNECTION_ERROR_NONE";
+		case 2: return "NEURIO_CONNECTION_ERROR_UNKNOWN";
+		case 3: return "NEURIO_CONNECTION_ERROR_WIFI_AP";
+		case 4: return "NEURIO_CONNECTION_ERROR_PAIRING_COMMAND";
+		case 5: return "NEURIO_CONNECTION_ERROR_REBOOT_COMMAND";
+		default: return "UNRECOGNIZED";
+	}
+}
+let NeurioCtType = /* @__PURE__ */ function(NeurioCtType) {
+	NeurioCtType[NeurioCtType["NEURIO_CT_TYPE_INVALID"] = 0] = "NEURIO_CT_TYPE_INVALID";
+	NeurioCtType[NeurioCtType["NEURIO_CT_TYPE_MISSING"] = 1] = "NEURIO_CT_TYPE_MISSING";
+	NeurioCtType[NeurioCtType["NEURIO_CT_TYPE_200A"] = 2] = "NEURIO_CT_TYPE_200A";
+	NeurioCtType[NeurioCtType["NEURIO_CT_TYPE_800A"] = 3] = "NEURIO_CT_TYPE_800A";
+	NeurioCtType[NeurioCtType["NEURIO_CT_TYPE_UNIVERSAL"] = 4] = "NEURIO_CT_TYPE_UNIVERSAL";
+	NeurioCtType[NeurioCtType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+	return NeurioCtType;
+}({});
+function neurioCtTypeFromJSON(object) {
+	switch (object) {
+		case 0:
+		case "NEURIO_CT_TYPE_INVALID": return 0;
+		case 1:
+		case "NEURIO_CT_TYPE_MISSING": return 1;
+		case 2:
+		case "NEURIO_CT_TYPE_200A": return 2;
+		case 3:
+		case "NEURIO_CT_TYPE_800A": return 3;
+		case 4:
+		case "NEURIO_CT_TYPE_UNIVERSAL": return 4;
+		default: return -1;
+	}
+}
+function neurioCtTypeToJSON(object) {
+	switch (object) {
+		case 0: return "NEURIO_CT_TYPE_INVALID";
+		case 1: return "NEURIO_CT_TYPE_MISSING";
+		case 2: return "NEURIO_CT_TYPE_200A";
+		case 3: return "NEURIO_CT_TYPE_800A";
+		case 4: return "NEURIO_CT_TYPE_UNIVERSAL";
+		default: return "UNRECOGNIZED";
+	}
+}
+let NeurioCtConfigRequestStatus = /* @__PURE__ */ function(NeurioCtConfigRequestStatus) {
+	NeurioCtConfigRequestStatus[NeurioCtConfigRequestStatus["NEURIO_CT_CONFIG_REQUEST_STATUS_INVALID"] = 0] = "NEURIO_CT_CONFIG_REQUEST_STATUS_INVALID";
+	NeurioCtConfigRequestStatus[NeurioCtConfigRequestStatus["NEURIO_CT_CONFIG_REQUEST_STATUS_SUCCESS"] = 1] = "NEURIO_CT_CONFIG_REQUEST_STATUS_SUCCESS";
+	NeurioCtConfigRequestStatus[NeurioCtConfigRequestStatus["NEURIO_CT_CONFIG_REQUEST_STATUS_FAILED_NETWORK"] = 2] = "NEURIO_CT_CONFIG_REQUEST_STATUS_FAILED_NETWORK";
+	NeurioCtConfigRequestStatus[NeurioCtConfigRequestStatus["NEURIO_CT_CONFIG_REQUEST_STATUS_FAILED_HTTP"] = 3] = "NEURIO_CT_CONFIG_REQUEST_STATUS_FAILED_HTTP";
+	NeurioCtConfigRequestStatus[NeurioCtConfigRequestStatus["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+	return NeurioCtConfigRequestStatus;
+}({});
+function neurioCtConfigRequestStatusFromJSON(object) {
+	switch (object) {
+		case 0:
+		case "NEURIO_CT_CONFIG_REQUEST_STATUS_INVALID": return 0;
+		case 1:
+		case "NEURIO_CT_CONFIG_REQUEST_STATUS_SUCCESS": return 1;
+		case 2:
+		case "NEURIO_CT_CONFIG_REQUEST_STATUS_FAILED_NETWORK": return 2;
+		case 3:
+		case "NEURIO_CT_CONFIG_REQUEST_STATUS_FAILED_HTTP": return 3;
+		default: return -1;
+	}
+}
+function neurioCtConfigRequestStatusToJSON(object) {
+	switch (object) {
+		case 0: return "NEURIO_CT_CONFIG_REQUEST_STATUS_INVALID";
+		case 1: return "NEURIO_CT_CONFIG_REQUEST_STATUS_SUCCESS";
+		case 2: return "NEURIO_CT_CONFIG_REQUEST_STATUS_FAILED_NETWORK";
+		case 3: return "NEURIO_CT_CONFIG_REQUEST_STATUS_FAILED_HTTP";
+		default: return "UNRECOGNIZED";
+	}
+}
+let NeurioCompatibleMeterType = /* @__PURE__ */ function(NeurioCompatibleMeterType) {
+	NeurioCompatibleMeterType[NeurioCompatibleMeterType["NEURIO_COMPATIBLE_METER_TYPE_INVALID"] = 0] = "NEURIO_COMPATIBLE_METER_TYPE_INVALID";
+	NeurioCompatibleMeterType[NeurioCompatibleMeterType["NEURIO_COMPATIBLE_METER_TYPE_NEURIO"] = 1] = "NEURIO_COMPATIBLE_METER_TYPE_NEURIO";
+	NeurioCompatibleMeterType[NeurioCompatibleMeterType["NEURIO_COMPATIBLE_METER_TYPE_TRM"] = 2] = "NEURIO_COMPATIBLE_METER_TYPE_TRM";
+	NeurioCompatibleMeterType[NeurioCompatibleMeterType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+	return NeurioCompatibleMeterType;
+}({});
+function neurioCompatibleMeterTypeFromJSON(object) {
+	switch (object) {
+		case 0:
+		case "NEURIO_COMPATIBLE_METER_TYPE_INVALID": return 0;
+		case 1:
+		case "NEURIO_COMPATIBLE_METER_TYPE_NEURIO": return 1;
+		case 2:
+		case "NEURIO_COMPATIBLE_METER_TYPE_TRM": return 2;
+		default: return -1;
+	}
+}
+function neurioCompatibleMeterTypeToJSON(object) {
+	switch (object) {
+		case 0: return "NEURIO_COMPATIBLE_METER_TYPE_INVALID";
+		case 1: return "NEURIO_COMPATIBLE_METER_TYPE_NEURIO";
+		case 2: return "NEURIO_COMPATIBLE_METER_TYPE_TRM";
+		default: return "UNRECOGNIZED";
+	}
+}
+function createBaseNeurioCTConfig() {
+	return {
+		location: 0,
+		realPowerScaleFactor: 0
+	};
+}
+const NeurioCTConfig = {
+	encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
+		if (message.location !== 0) writer.uint32(8).int32(message.location);
+		if (message.realPowerScaleFactor !== 0) writer.uint32(21).float(message.realPowerScaleFactor);
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
+		const end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseNeurioCTConfig();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 8) break;
+					message.location = reader.int32();
+					continue;
+				case 2:
+					if (tag !== 21) break;
+					message.realPowerScaleFactor = reader.float();
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			location: isSet(object.location) ? globalThis.Number(object.location) : 0,
+			realPowerScaleFactor: isSet(object.realPowerScaleFactor) ? globalThis.Number(object.realPowerScaleFactor) : 0
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.location !== void 0) obj.location = Math.round(message.location);
+		if (message.realPowerScaleFactor !== void 0) obj.realPowerScaleFactor = message.realPowerScaleFactor;
+		return obj;
+	},
+	create(base) {
+		return NeurioCTConfig.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseNeurioCTConfig();
+		message.location = object.location ?? 0;
+		message.realPowerScaleFactor = object.realPowerScaleFactor ?? 0;
+		return message;
+	}
+};
+function createBaseNeurioCTReading() {
+	return {
+		realPowerW: 0,
+		scaledRealPowerW: 0,
+		currentAmps: 0
+	};
+}
+const NeurioCTReading = {
+	encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
+		if (message.realPowerW !== 0) writer.uint32(13).float(message.realPowerW);
+		if (message.scaledRealPowerW !== 0) writer.uint32(21).float(message.scaledRealPowerW);
+		if (message.currentAmps !== 0) writer.uint32(29).float(message.currentAmps);
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
+		const end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseNeurioCTReading();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 13) break;
+					message.realPowerW = reader.float();
+					continue;
+				case 2:
+					if (tag !== 21) break;
+					message.scaledRealPowerW = reader.float();
+					continue;
+				case 3:
+					if (tag !== 29) break;
+					message.currentAmps = reader.float();
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			realPowerW: isSet(object.realPowerW) ? globalThis.Number(object.realPowerW) : 0,
+			scaledRealPowerW: isSet(object.scaledRealPowerW) ? globalThis.Number(object.scaledRealPowerW) : 0,
+			currentAmps: isSet(object.currentAmps) ? globalThis.Number(object.currentAmps) : 0
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.realPowerW !== void 0) obj.realPowerW = message.realPowerW;
+		if (message.scaledRealPowerW !== void 0) obj.scaledRealPowerW = message.scaledRealPowerW;
+		if (message.currentAmps !== void 0) obj.currentAmps = message.currentAmps;
+		return obj;
+	},
+	create(base) {
+		return NeurioCTReading.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseNeurioCTReading();
+		message.realPowerW = object.realPowerW ?? 0;
+		message.scaledRealPowerW = object.scaledRealPowerW ?? 0;
+		message.currentAmps = object.currentAmps ?? 0;
+		return message;
+	}
+};
+function createBaseNeurioMeterReadings() {
+	return { ctReadings: [] };
+}
+const NeurioMeterReadings = {
+	encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
+		for (const v of message.ctReadings) NeurioCTReading.encode(v, writer.uint32(10).fork()).join();
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
+		const end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseNeurioMeterReadings();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.ctReadings.push(NeurioCTReading.decode(reader, reader.uint32()));
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return { ctReadings: globalThis.Array.isArray(object?.ctReadings) ? object.ctReadings.map((e) => NeurioCTReading.fromJSON(e)) : [] };
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.ctReadings?.length) obj.ctReadings = message.ctReadings.map((e) => NeurioCTReading.toJSON(e));
+		return obj;
+	},
+	create(base) {
+		return NeurioMeterReadings.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseNeurioMeterReadings();
+		message.ctReadings = object.ctReadings?.map((e) => NeurioCTReading.fromPartial(e)) || [];
+		return message;
+	}
+};
+function createBaseNeurioMeterConnection() {
+	return {
+		connectionStatus: 0,
+		connectionError: 0,
+		rssi: void 0,
+		firmwareVersion: "",
+		meterReadings: void 0
+	};
+}
+const NeurioMeterConnection = {
+	encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
+		if (message.connectionStatus !== 0) writer.uint32(8).int32(message.connectionStatus);
+		if (message.connectionError !== 0) writer.uint32(16).int32(message.connectionError);
+		if (message.rssi !== void 0) require_energy_device_networking.Rssi.encode(message.rssi, writer.uint32(26).fork()).join();
+		if (message.firmwareVersion !== "") writer.uint32(34).string(message.firmwareVersion);
+		if (message.meterReadings !== void 0) NeurioMeterReadings.encode(message.meterReadings, writer.uint32(42).fork()).join();
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
+		const end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseNeurioMeterConnection();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 8) break;
+					message.connectionStatus = reader.int32();
+					continue;
+				case 2:
+					if (tag !== 16) break;
+					message.connectionError = reader.int32();
+					continue;
+				case 3:
+					if (tag !== 26) break;
+					message.rssi = require_energy_device_networking.Rssi.decode(reader, reader.uint32());
+					continue;
+				case 4:
+					if (tag !== 34) break;
+					message.firmwareVersion = reader.string();
+					continue;
+				case 5:
+					if (tag !== 42) break;
+					message.meterReadings = NeurioMeterReadings.decode(reader, reader.uint32());
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			connectionStatus: isSet(object.connectionStatus) ? neurioConnectionStatusFromJSON(object.connectionStatus) : 0,
+			connectionError: isSet(object.connectionError) ? neurioConnectionErrorFromJSON(object.connectionError) : 0,
+			rssi: isSet(object.rssi) ? require_energy_device_networking.Rssi.fromJSON(object.rssi) : void 0,
+			firmwareVersion: isSet(object.firmwareVersion) ? globalThis.String(object.firmwareVersion) : "",
+			meterReadings: isSet(object.meterReadings) ? NeurioMeterReadings.fromJSON(object.meterReadings) : void 0
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.connectionStatus !== void 0) obj.connectionStatus = neurioConnectionStatusToJSON(message.connectionStatus);
+		if (message.connectionError !== void 0) obj.connectionError = neurioConnectionErrorToJSON(message.connectionError);
+		if (message.rssi !== void 0) obj.rssi = require_energy_device_networking.Rssi.toJSON(message.rssi);
+		if (message.firmwareVersion !== void 0) obj.firmwareVersion = message.firmwareVersion;
+		if (message.meterReadings !== void 0) obj.meterReadings = NeurioMeterReadings.toJSON(message.meterReadings);
+		return obj;
+	},
+	create(base) {
+		return NeurioMeterConnection.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseNeurioMeterConnection();
+		message.connectionStatus = object.connectionStatus ?? 0;
+		message.connectionError = object.connectionError ?? 0;
+		message.rssi = object.rssi !== void 0 && object.rssi !== null ? require_energy_device_networking.Rssi.fromPartial(object.rssi) : void 0;
+		message.firmwareVersion = object.firmwareVersion ?? "";
+		message.meterReadings = object.meterReadings !== void 0 && object.meterReadings !== null ? NeurioMeterReadings.fromPartial(object.meterReadings) : void 0;
+		return message;
+	}
+};
+function createBaseNeurioMeterConfig() {
+	return {
+		shortId: "",
+		serial: "",
+		ctConfig: [],
+		meterType: 0
+	};
+}
+const NeurioMeterConfig = {
+	encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
+		if (message.shortId !== "") writer.uint32(10).string(message.shortId);
+		if (message.serial !== "") writer.uint32(18).string(message.serial);
+		for (const v of message.ctConfig) NeurioCTConfig.encode(v, writer.uint32(26).fork()).join();
+		if (message.meterType !== 0) writer.uint32(32).int32(message.meterType);
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
+		const end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseNeurioMeterConfig();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.shortId = reader.string();
+					continue;
+				case 2:
+					if (tag !== 18) break;
+					message.serial = reader.string();
+					continue;
+				case 3:
+					if (tag !== 26) break;
+					message.ctConfig.push(NeurioCTConfig.decode(reader, reader.uint32()));
+					continue;
+				case 4:
+					if (tag !== 32) break;
+					message.meterType = reader.int32();
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			shortId: isSet(object.shortId) ? globalThis.String(object.shortId) : "",
+			serial: isSet(object.serial) ? globalThis.String(object.serial) : "",
+			ctConfig: globalThis.Array.isArray(object?.ctConfig) ? object.ctConfig.map((e) => NeurioCTConfig.fromJSON(e)) : [],
+			meterType: isSet(object.meterType) ? neurioCompatibleMeterTypeFromJSON(object.meterType) : 0
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.shortId !== void 0) obj.shortId = message.shortId;
+		if (message.serial !== void 0) obj.serial = message.serial;
+		if (message.ctConfig?.length) obj.ctConfig = message.ctConfig.map((e) => NeurioCTConfig.toJSON(e));
+		if (message.meterType !== void 0) obj.meterType = neurioCompatibleMeterTypeToJSON(message.meterType);
+		return obj;
+	},
+	create(base) {
+		return NeurioMeterConfig.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseNeurioMeterConfig();
+		message.shortId = object.shortId ?? "";
+		message.serial = object.serial ?? "";
+		message.ctConfig = object.ctConfig?.map((e) => NeurioCTConfig.fromPartial(e)) || [];
+		message.meterType = object.meterType ?? 0;
+		return message;
+	}
+};
+function createBaseNeurioMeterInterface() {
+	return {
+		config: void 0,
+		connection: void 0
+	};
+}
+const NeurioMeterInterface = {
+	encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
+		if (message.config !== void 0) NeurioMeterConfig.encode(message.config, writer.uint32(10).fork()).join();
+		if (message.connection !== void 0) NeurioMeterConnection.encode(message.connection, writer.uint32(18).fork()).join();
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
+		const end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseNeurioMeterInterface();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.config = NeurioMeterConfig.decode(reader, reader.uint32());
+					continue;
+				case 2:
+					if (tag !== 18) break;
+					message.connection = NeurioMeterConnection.decode(reader, reader.uint32());
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			config: isSet(object.config) ? NeurioMeterConfig.fromJSON(object.config) : void 0,
+			connection: isSet(object.connection) ? NeurioMeterConnection.fromJSON(object.connection) : void 0
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.config !== void 0) obj.config = NeurioMeterConfig.toJSON(message.config);
+		if (message.connection !== void 0) obj.connection = NeurioMeterConnection.toJSON(message.connection);
+		return obj;
+	},
+	create(base) {
+		return NeurioMeterInterface.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseNeurioMeterInterface();
+		message.config = object.config !== void 0 && object.config !== null ? NeurioMeterConfig.fromPartial(object.config) : void 0;
+		message.connection = object.connection !== void 0 && object.connection !== null ? NeurioMeterConnection.fromPartial(object.connection) : void 0;
+		return message;
+	}
+};
+function createBaseNeurioMeterAPIAddMeterRequest() {
+	return { config: void 0 };
+}
+const NeurioMeterAPIAddMeterRequest = {
+	encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
+		if (message.config !== void 0) NeurioMeterConfig.encode(message.config, writer.uint32(10).fork()).join();
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
+		const end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseNeurioMeterAPIAddMeterRequest();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.config = NeurioMeterConfig.decode(reader, reader.uint32());
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return { config: isSet(object.config) ? NeurioMeterConfig.fromJSON(object.config) : void 0 };
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.config !== void 0) obj.config = NeurioMeterConfig.toJSON(message.config);
+		return obj;
+	},
+	create(base) {
+		return NeurioMeterAPIAddMeterRequest.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseNeurioMeterAPIAddMeterRequest();
+		message.config = object.config !== void 0 && object.config !== null ? NeurioMeterConfig.fromPartial(object.config) : void 0;
+		return message;
+	}
+};
+function createBaseNeurioMeterAPIAddMeterResponse() {
+	return { config: void 0 };
+}
+const NeurioMeterAPIAddMeterResponse = {
+	encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
+		if (message.config !== void 0) NeurioMeterConfig.encode(message.config, writer.uint32(10).fork()).join();
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
+		const end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseNeurioMeterAPIAddMeterResponse();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.config = NeurioMeterConfig.decode(reader, reader.uint32());
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return { config: isSet(object.config) ? NeurioMeterConfig.fromJSON(object.config) : void 0 };
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.config !== void 0) obj.config = NeurioMeterConfig.toJSON(message.config);
+		return obj;
+	},
+	create(base) {
+		return NeurioMeterAPIAddMeterResponse.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseNeurioMeterAPIAddMeterResponse();
+		message.config = object.config !== void 0 && object.config !== null ? NeurioMeterConfig.fromPartial(object.config) : void 0;
+		return message;
+	}
+};
+function createBaseNeurioMeterAPIRemoveMeterRequest() {
+	return { serial: "" };
+}
+const NeurioMeterAPIRemoveMeterRequest = {
+	encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
+		if (message.serial !== "") writer.uint32(10).string(message.serial);
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
+		const end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseNeurioMeterAPIRemoveMeterRequest();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.serial = reader.string();
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return { serial: isSet(object.serial) ? globalThis.String(object.serial) : "" };
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.serial !== void 0) obj.serial = message.serial;
+		return obj;
+	},
+	create(base) {
+		return NeurioMeterAPIRemoveMeterRequest.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseNeurioMeterAPIRemoveMeterRequest();
+		message.serial = object.serial ?? "";
+		return message;
+	}
+};
+function createBaseNeurioMeterAPIRemoveMeterResponse() {
+	return {};
+}
+const NeurioMeterAPIRemoveMeterResponse = {
+	encode(_, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
+		const end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseNeurioMeterAPIRemoveMeterResponse();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(_) {
+		return {};
+	},
+	toJSON(_) {
+		return {};
+	},
+	create(base) {
+		return NeurioMeterAPIRemoveMeterResponse.fromPartial(base ?? {});
+	},
+	fromPartial(_) {
+		return createBaseNeurioMeterAPIRemoveMeterResponse();
+	}
+};
+function createBaseNeurioMeterAPIConfigureCtsRequest() {
+	return {
+		serial: "",
+		ctConfig: []
+	};
+}
+const NeurioMeterAPIConfigureCtsRequest = {
+	encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
+		if (message.serial !== "") writer.uint32(10).string(message.serial);
+		for (const v of message.ctConfig) NeurioCTConfig.encode(v, writer.uint32(18).fork()).join();
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
+		const end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseNeurioMeterAPIConfigureCtsRequest();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.serial = reader.string();
+					continue;
+				case 2:
+					if (tag !== 18) break;
+					message.ctConfig.push(NeurioCTConfig.decode(reader, reader.uint32()));
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			serial: isSet(object.serial) ? globalThis.String(object.serial) : "",
+			ctConfig: globalThis.Array.isArray(object?.ctConfig) ? object.ctConfig.map((e) => NeurioCTConfig.fromJSON(e)) : []
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.serial !== void 0) obj.serial = message.serial;
+		if (message.ctConfig?.length) obj.ctConfig = message.ctConfig.map((e) => NeurioCTConfig.toJSON(e));
+		return obj;
+	},
+	create(base) {
+		return NeurioMeterAPIConfigureCtsRequest.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseNeurioMeterAPIConfigureCtsRequest();
+		message.serial = object.serial ?? "";
+		message.ctConfig = object.ctConfig?.map((e) => NeurioCTConfig.fromPartial(e)) || [];
+		return message;
+	}
+};
+function createBaseNeurioMeterAPIConfigureCtsResponse() {
+	return { ctConfig: [] };
+}
+const NeurioMeterAPIConfigureCtsResponse = {
+	encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
+		for (const v of message.ctConfig) NeurioCTConfig.encode(v, writer.uint32(10).fork()).join();
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
+		const end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseNeurioMeterAPIConfigureCtsResponse();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.ctConfig.push(NeurioCTConfig.decode(reader, reader.uint32()));
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return { ctConfig: globalThis.Array.isArray(object?.ctConfig) ? object.ctConfig.map((e) => NeurioCTConfig.fromJSON(e)) : [] };
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.ctConfig?.length) obj.ctConfig = message.ctConfig.map((e) => NeurioCTConfig.toJSON(e));
+		return obj;
+	},
+	create(base) {
+		return NeurioMeterAPIConfigureCtsResponse.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseNeurioMeterAPIConfigureCtsResponse();
+		message.ctConfig = object.ctConfig?.map((e) => NeurioCTConfig.fromPartial(e)) || [];
+		return message;
+	}
+};
+function createBaseNeurioMeterAPIDetectWiredRequest() {
+	return {};
+}
+const NeurioMeterAPIDetectWiredRequest = {
+	encode(_, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
+		const end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseNeurioMeterAPIDetectWiredRequest();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(_) {
+		return {};
+	},
+	toJSON(_) {
+		return {};
+	},
+	create(base) {
+		return NeurioMeterAPIDetectWiredRequest.fromPartial(base ?? {});
+	},
+	fromPartial(_) {
+		return createBaseNeurioMeterAPIDetectWiredRequest();
+	}
+};
+function createBaseNeurioMeterAPIDetectWiredResponse() {
+	return {};
+}
+const NeurioMeterAPIDetectWiredResponse = {
+	encode(_, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
+		const end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseNeurioMeterAPIDetectWiredResponse();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(_) {
+		return {};
+	},
+	toJSON(_) {
+		return {};
+	},
+	create(base) {
+		return NeurioMeterAPIDetectWiredResponse.fromPartial(base ?? {});
+	},
+	fromPartial(_) {
+		return createBaseNeurioMeterAPIDetectWiredResponse();
+	}
+};
+function createBaseNeurioMeterAPIGetNeurioCtTypeRequest() {
+	return { serial: "" };
+}
+const NeurioMeterAPIGetNeurioCtTypeRequest = {
+	encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
+		if (message.serial !== "") writer.uint32(10).string(message.serial);
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
+		const end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseNeurioMeterAPIGetNeurioCtTypeRequest();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.serial = reader.string();
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return { serial: isSet(object.serial) ? globalThis.String(object.serial) : "" };
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.serial !== void 0) obj.serial = message.serial;
+		return obj;
+	},
+	create(base) {
+		return NeurioMeterAPIGetNeurioCtTypeRequest.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseNeurioMeterAPIGetNeurioCtTypeRequest();
+		message.serial = object.serial ?? "";
+		return message;
+	}
+};
+function createBaseNeurioMeterAPIGetNeurioCtTypeResponse() {
+	return {
+		serial: "",
+		status: 0,
+		ct1Type: 0,
+		ct2Type: 0,
+		ct3Type: 0,
+		ct4Type: 0
+	};
+}
+const NeurioMeterAPIGetNeurioCtTypeResponse = {
+	encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
+		if (message.serial !== "") writer.uint32(10).string(message.serial);
+		if (message.status !== 0) writer.uint32(16).int32(message.status);
+		if (message.ct1Type !== 0) writer.uint32(24).int32(message.ct1Type);
+		if (message.ct2Type !== 0) writer.uint32(32).int32(message.ct2Type);
+		if (message.ct3Type !== 0) writer.uint32(40).int32(message.ct3Type);
+		if (message.ct4Type !== 0) writer.uint32(48).int32(message.ct4Type);
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
+		const end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseNeurioMeterAPIGetNeurioCtTypeResponse();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.serial = reader.string();
+					continue;
+				case 2:
+					if (tag !== 16) break;
+					message.status = reader.int32();
+					continue;
+				case 3:
+					if (tag !== 24) break;
+					message.ct1Type = reader.int32();
+					continue;
+				case 4:
+					if (tag !== 32) break;
+					message.ct2Type = reader.int32();
+					continue;
+				case 5:
+					if (tag !== 40) break;
+					message.ct3Type = reader.int32();
+					continue;
+				case 6:
+					if (tag !== 48) break;
+					message.ct4Type = reader.int32();
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			serial: isSet(object.serial) ? globalThis.String(object.serial) : "",
+			status: isSet(object.status) ? neurioCtConfigRequestStatusFromJSON(object.status) : 0,
+			ct1Type: isSet(object.ct1Type) ? neurioCtTypeFromJSON(object.ct1Type) : 0,
+			ct2Type: isSet(object.ct2Type) ? neurioCtTypeFromJSON(object.ct2Type) : 0,
+			ct3Type: isSet(object.ct3Type) ? neurioCtTypeFromJSON(object.ct3Type) : 0,
+			ct4Type: isSet(object.ct4Type) ? neurioCtTypeFromJSON(object.ct4Type) : 0
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.serial !== void 0) obj.serial = message.serial;
+		if (message.status !== void 0) obj.status = neurioCtConfigRequestStatusToJSON(message.status);
+		if (message.ct1Type !== void 0) obj.ct1Type = neurioCtTypeToJSON(message.ct1Type);
+		if (message.ct2Type !== void 0) obj.ct2Type = neurioCtTypeToJSON(message.ct2Type);
+		if (message.ct3Type !== void 0) obj.ct3Type = neurioCtTypeToJSON(message.ct3Type);
+		if (message.ct4Type !== void 0) obj.ct4Type = neurioCtTypeToJSON(message.ct4Type);
+		return obj;
+	},
+	create(base) {
+		return NeurioMeterAPIGetNeurioCtTypeResponse.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseNeurioMeterAPIGetNeurioCtTypeResponse();
+		message.serial = object.serial ?? "";
+		message.status = object.status ?? 0;
+		message.ct1Type = object.ct1Type ?? 0;
+		message.ct2Type = object.ct2Type ?? 0;
+		message.ct3Type = object.ct3Type ?? 0;
+		message.ct4Type = object.ct4Type ?? 0;
+		return message;
+	}
+};
+function createBaseNeurioMeterAPISetNeurioCtTypeRequest() {
+	return {
+		serial: "",
+		ct1Type: 0,
+		ct2Type: 0,
+		ct3Type: 0,
+		ct4Type: 0
+	};
+}
+const NeurioMeterAPISetNeurioCtTypeRequest = {
+	encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
+		if (message.serial !== "") writer.uint32(10).string(message.serial);
+		if (message.ct1Type !== 0) writer.uint32(24).int32(message.ct1Type);
+		if (message.ct2Type !== 0) writer.uint32(32).int32(message.ct2Type);
+		if (message.ct3Type !== 0) writer.uint32(40).int32(message.ct3Type);
+		if (message.ct4Type !== 0) writer.uint32(48).int32(message.ct4Type);
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
+		const end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseNeurioMeterAPISetNeurioCtTypeRequest();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.serial = reader.string();
+					continue;
+				case 3:
+					if (tag !== 24) break;
+					message.ct1Type = reader.int32();
+					continue;
+				case 4:
+					if (tag !== 32) break;
+					message.ct2Type = reader.int32();
+					continue;
+				case 5:
+					if (tag !== 40) break;
+					message.ct3Type = reader.int32();
+					continue;
+				case 6:
+					if (tag !== 48) break;
+					message.ct4Type = reader.int32();
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			serial: isSet(object.serial) ? globalThis.String(object.serial) : "",
+			ct1Type: isSet(object.ct1Type) ? neurioCtTypeFromJSON(object.ct1Type) : 0,
+			ct2Type: isSet(object.ct2Type) ? neurioCtTypeFromJSON(object.ct2Type) : 0,
+			ct3Type: isSet(object.ct3Type) ? neurioCtTypeFromJSON(object.ct3Type) : 0,
+			ct4Type: isSet(object.ct4Type) ? neurioCtTypeFromJSON(object.ct4Type) : 0
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.serial !== void 0) obj.serial = message.serial;
+		if (message.ct1Type !== void 0) obj.ct1Type = neurioCtTypeToJSON(message.ct1Type);
+		if (message.ct2Type !== void 0) obj.ct2Type = neurioCtTypeToJSON(message.ct2Type);
+		if (message.ct3Type !== void 0) obj.ct3Type = neurioCtTypeToJSON(message.ct3Type);
+		if (message.ct4Type !== void 0) obj.ct4Type = neurioCtTypeToJSON(message.ct4Type);
+		return obj;
+	},
+	create(base) {
+		return NeurioMeterAPISetNeurioCtTypeRequest.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseNeurioMeterAPISetNeurioCtTypeRequest();
+		message.serial = object.serial ?? "";
+		message.ct1Type = object.ct1Type ?? 0;
+		message.ct2Type = object.ct2Type ?? 0;
+		message.ct3Type = object.ct3Type ?? 0;
+		message.ct4Type = object.ct4Type ?? 0;
+		return message;
+	}
+};
+function createBaseNeurioMeterAPISetNeurioCtTypeResponse() {
+	return {
+		serial: "",
+		status: 0,
+		ct1Type: 0,
+		ct2Type: 0,
+		ct3Type: 0,
+		ct4Type: 0
+	};
+}
+const NeurioMeterAPISetNeurioCtTypeResponse = {
+	encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
+		if (message.serial !== "") writer.uint32(10).string(message.serial);
+		if (message.status !== 0) writer.uint32(16).int32(message.status);
+		if (message.ct1Type !== 0) writer.uint32(24).int32(message.ct1Type);
+		if (message.ct2Type !== 0) writer.uint32(32).int32(message.ct2Type);
+		if (message.ct3Type !== 0) writer.uint32(40).int32(message.ct3Type);
+		if (message.ct4Type !== 0) writer.uint32(48).int32(message.ct4Type);
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
+		const end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseNeurioMeterAPISetNeurioCtTypeResponse();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.serial = reader.string();
+					continue;
+				case 2:
+					if (tag !== 16) break;
+					message.status = reader.int32();
+					continue;
+				case 3:
+					if (tag !== 24) break;
+					message.ct1Type = reader.int32();
+					continue;
+				case 4:
+					if (tag !== 32) break;
+					message.ct2Type = reader.int32();
+					continue;
+				case 5:
+					if (tag !== 40) break;
+					message.ct3Type = reader.int32();
+					continue;
+				case 6:
+					if (tag !== 48) break;
+					message.ct4Type = reader.int32();
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			serial: isSet(object.serial) ? globalThis.String(object.serial) : "",
+			status: isSet(object.status) ? neurioCtConfigRequestStatusFromJSON(object.status) : 0,
+			ct1Type: isSet(object.ct1Type) ? neurioCtTypeFromJSON(object.ct1Type) : 0,
+			ct2Type: isSet(object.ct2Type) ? neurioCtTypeFromJSON(object.ct2Type) : 0,
+			ct3Type: isSet(object.ct3Type) ? neurioCtTypeFromJSON(object.ct3Type) : 0,
+			ct4Type: isSet(object.ct4Type) ? neurioCtTypeFromJSON(object.ct4Type) : 0
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.serial !== void 0) obj.serial = message.serial;
+		if (message.status !== void 0) obj.status = neurioCtConfigRequestStatusToJSON(message.status);
+		if (message.ct1Type !== void 0) obj.ct1Type = neurioCtTypeToJSON(message.ct1Type);
+		if (message.ct2Type !== void 0) obj.ct2Type = neurioCtTypeToJSON(message.ct2Type);
+		if (message.ct3Type !== void 0) obj.ct3Type = neurioCtTypeToJSON(message.ct3Type);
+		if (message.ct4Type !== void 0) obj.ct4Type = neurioCtTypeToJSON(message.ct4Type);
+		return obj;
+	},
+	create(base) {
+		return NeurioMeterAPISetNeurioCtTypeResponse.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseNeurioMeterAPISetNeurioCtTypeResponse();
+		message.serial = object.serial ?? "";
+		message.status = object.status ?? 0;
+		message.ct1Type = object.ct1Type ?? 0;
+		message.ct2Type = object.ct2Type ?? 0;
+		message.ct3Type = object.ct3Type ?? 0;
+		message.ct4Type = object.ct4Type ?? 0;
+		return message;
+	}
+};
+function createBaseNeurioMeterMessages() {
+	return {
+		addMeterRequest: void 0,
+		addMeterResponse: void 0,
+		removeMeterRequest: void 0,
+		removeMeterResponse: void 0,
+		configureCtsRequest: void 0,
+		configureCtsResponse: void 0,
+		detectWiredRequest: void 0,
+		detectWiredResponse: void 0,
+		getNeurioCtTypeRequest: void 0,
+		getNeurioCtTypeResponse: void 0,
+		setNeurioCtTypeRequest: void 0,
+		setNeurioCtTypeResponse: void 0
+	};
+}
+const NeurioMeterMessages = {
+	encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
+		if (message.addMeterRequest !== void 0) NeurioMeterAPIAddMeterRequest.encode(message.addMeterRequest, writer.uint32(10).fork()).join();
+		if (message.addMeterResponse !== void 0) NeurioMeterAPIAddMeterResponse.encode(message.addMeterResponse, writer.uint32(18).fork()).join();
+		if (message.removeMeterRequest !== void 0) NeurioMeterAPIRemoveMeterRequest.encode(message.removeMeterRequest, writer.uint32(26).fork()).join();
+		if (message.removeMeterResponse !== void 0) NeurioMeterAPIRemoveMeterResponse.encode(message.removeMeterResponse, writer.uint32(34).fork()).join();
+		if (message.configureCtsRequest !== void 0) NeurioMeterAPIConfigureCtsRequest.encode(message.configureCtsRequest, writer.uint32(42).fork()).join();
+		if (message.configureCtsResponse !== void 0) NeurioMeterAPIConfigureCtsResponse.encode(message.configureCtsResponse, writer.uint32(50).fork()).join();
+		if (message.detectWiredRequest !== void 0) NeurioMeterAPIDetectWiredRequest.encode(message.detectWiredRequest, writer.uint32(58).fork()).join();
+		if (message.detectWiredResponse !== void 0) NeurioMeterAPIDetectWiredResponse.encode(message.detectWiredResponse, writer.uint32(66).fork()).join();
+		if (message.getNeurioCtTypeRequest !== void 0) NeurioMeterAPIGetNeurioCtTypeRequest.encode(message.getNeurioCtTypeRequest, writer.uint32(74).fork()).join();
+		if (message.getNeurioCtTypeResponse !== void 0) NeurioMeterAPIGetNeurioCtTypeResponse.encode(message.getNeurioCtTypeResponse, writer.uint32(82).fork()).join();
+		if (message.setNeurioCtTypeRequest !== void 0) NeurioMeterAPISetNeurioCtTypeRequest.encode(message.setNeurioCtTypeRequest, writer.uint32(90).fork()).join();
+		if (message.setNeurioCtTypeResponse !== void 0) NeurioMeterAPISetNeurioCtTypeResponse.encode(message.setNeurioCtTypeResponse, writer.uint32(98).fork()).join();
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
+		const end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseNeurioMeterMessages();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.addMeterRequest = NeurioMeterAPIAddMeterRequest.decode(reader, reader.uint32());
+					continue;
+				case 2:
+					if (tag !== 18) break;
+					message.addMeterResponse = NeurioMeterAPIAddMeterResponse.decode(reader, reader.uint32());
+					continue;
+				case 3:
+					if (tag !== 26) break;
+					message.removeMeterRequest = NeurioMeterAPIRemoveMeterRequest.decode(reader, reader.uint32());
+					continue;
+				case 4:
+					if (tag !== 34) break;
+					message.removeMeterResponse = NeurioMeterAPIRemoveMeterResponse.decode(reader, reader.uint32());
+					continue;
+				case 5:
+					if (tag !== 42) break;
+					message.configureCtsRequest = NeurioMeterAPIConfigureCtsRequest.decode(reader, reader.uint32());
+					continue;
+				case 6:
+					if (tag !== 50) break;
+					message.configureCtsResponse = NeurioMeterAPIConfigureCtsResponse.decode(reader, reader.uint32());
+					continue;
+				case 7:
+					if (tag !== 58) break;
+					message.detectWiredRequest = NeurioMeterAPIDetectWiredRequest.decode(reader, reader.uint32());
+					continue;
+				case 8:
+					if (tag !== 66) break;
+					message.detectWiredResponse = NeurioMeterAPIDetectWiredResponse.decode(reader, reader.uint32());
+					continue;
+				case 9:
+					if (tag !== 74) break;
+					message.getNeurioCtTypeRequest = NeurioMeterAPIGetNeurioCtTypeRequest.decode(reader, reader.uint32());
+					continue;
+				case 10:
+					if (tag !== 82) break;
+					message.getNeurioCtTypeResponse = NeurioMeterAPIGetNeurioCtTypeResponse.decode(reader, reader.uint32());
+					continue;
+				case 11:
+					if (tag !== 90) break;
+					message.setNeurioCtTypeRequest = NeurioMeterAPISetNeurioCtTypeRequest.decode(reader, reader.uint32());
+					continue;
+				case 12:
+					if (tag !== 98) break;
+					message.setNeurioCtTypeResponse = NeurioMeterAPISetNeurioCtTypeResponse.decode(reader, reader.uint32());
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			addMeterRequest: isSet(object.addMeterRequest) ? NeurioMeterAPIAddMeterRequest.fromJSON(object.addMeterRequest) : void 0,
+			addMeterResponse: isSet(object.addMeterResponse) ? NeurioMeterAPIAddMeterResponse.fromJSON(object.addMeterResponse) : void 0,
+			removeMeterRequest: isSet(object.removeMeterRequest) ? NeurioMeterAPIRemoveMeterRequest.fromJSON(object.removeMeterRequest) : void 0,
+			removeMeterResponse: isSet(object.removeMeterResponse) ? NeurioMeterAPIRemoveMeterResponse.fromJSON(object.removeMeterResponse) : void 0,
+			configureCtsRequest: isSet(object.configureCtsRequest) ? NeurioMeterAPIConfigureCtsRequest.fromJSON(object.configureCtsRequest) : void 0,
+			configureCtsResponse: isSet(object.configureCtsResponse) ? NeurioMeterAPIConfigureCtsResponse.fromJSON(object.configureCtsResponse) : void 0,
+			detectWiredRequest: isSet(object.detectWiredRequest) ? NeurioMeterAPIDetectWiredRequest.fromJSON(object.detectWiredRequest) : void 0,
+			detectWiredResponse: isSet(object.detectWiredResponse) ? NeurioMeterAPIDetectWiredResponse.fromJSON(object.detectWiredResponse) : void 0,
+			getNeurioCtTypeRequest: isSet(object.getNeurioCtTypeRequest) ? NeurioMeterAPIGetNeurioCtTypeRequest.fromJSON(object.getNeurioCtTypeRequest) : void 0,
+			getNeurioCtTypeResponse: isSet(object.getNeurioCtTypeResponse) ? NeurioMeterAPIGetNeurioCtTypeResponse.fromJSON(object.getNeurioCtTypeResponse) : void 0,
+			setNeurioCtTypeRequest: isSet(object.setNeurioCtTypeRequest) ? NeurioMeterAPISetNeurioCtTypeRequest.fromJSON(object.setNeurioCtTypeRequest) : void 0,
+			setNeurioCtTypeResponse: isSet(object.setNeurioCtTypeResponse) ? NeurioMeterAPISetNeurioCtTypeResponse.fromJSON(object.setNeurioCtTypeResponse) : void 0
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.addMeterRequest !== void 0) obj.addMeterRequest = NeurioMeterAPIAddMeterRequest.toJSON(message.addMeterRequest);
+		if (message.addMeterResponse !== void 0) obj.addMeterResponse = NeurioMeterAPIAddMeterResponse.toJSON(message.addMeterResponse);
+		if (message.removeMeterRequest !== void 0) obj.removeMeterRequest = NeurioMeterAPIRemoveMeterRequest.toJSON(message.removeMeterRequest);
+		if (message.removeMeterResponse !== void 0) obj.removeMeterResponse = NeurioMeterAPIRemoveMeterResponse.toJSON(message.removeMeterResponse);
+		if (message.configureCtsRequest !== void 0) obj.configureCtsRequest = NeurioMeterAPIConfigureCtsRequest.toJSON(message.configureCtsRequest);
+		if (message.configureCtsResponse !== void 0) obj.configureCtsResponse = NeurioMeterAPIConfigureCtsResponse.toJSON(message.configureCtsResponse);
+		if (message.detectWiredRequest !== void 0) obj.detectWiredRequest = NeurioMeterAPIDetectWiredRequest.toJSON(message.detectWiredRequest);
+		if (message.detectWiredResponse !== void 0) obj.detectWiredResponse = NeurioMeterAPIDetectWiredResponse.toJSON(message.detectWiredResponse);
+		if (message.getNeurioCtTypeRequest !== void 0) obj.getNeurioCtTypeRequest = NeurioMeterAPIGetNeurioCtTypeRequest.toJSON(message.getNeurioCtTypeRequest);
+		if (message.getNeurioCtTypeResponse !== void 0) obj.getNeurioCtTypeResponse = NeurioMeterAPIGetNeurioCtTypeResponse.toJSON(message.getNeurioCtTypeResponse);
+		if (message.setNeurioCtTypeRequest !== void 0) obj.setNeurioCtTypeRequest = NeurioMeterAPISetNeurioCtTypeRequest.toJSON(message.setNeurioCtTypeRequest);
+		if (message.setNeurioCtTypeResponse !== void 0) obj.setNeurioCtTypeResponse = NeurioMeterAPISetNeurioCtTypeResponse.toJSON(message.setNeurioCtTypeResponse);
+		return obj;
+	},
+	create(base) {
+		return NeurioMeterMessages.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseNeurioMeterMessages();
+		message.addMeterRequest = object.addMeterRequest !== void 0 && object.addMeterRequest !== null ? NeurioMeterAPIAddMeterRequest.fromPartial(object.addMeterRequest) : void 0;
+		message.addMeterResponse = object.addMeterResponse !== void 0 && object.addMeterResponse !== null ? NeurioMeterAPIAddMeterResponse.fromPartial(object.addMeterResponse) : void 0;
+		message.removeMeterRequest = object.removeMeterRequest !== void 0 && object.removeMeterRequest !== null ? NeurioMeterAPIRemoveMeterRequest.fromPartial(object.removeMeterRequest) : void 0;
+		message.removeMeterResponse = object.removeMeterResponse !== void 0 && object.removeMeterResponse !== null ? NeurioMeterAPIRemoveMeterResponse.fromPartial(object.removeMeterResponse) : void 0;
+		message.configureCtsRequest = object.configureCtsRequest !== void 0 && object.configureCtsRequest !== null ? NeurioMeterAPIConfigureCtsRequest.fromPartial(object.configureCtsRequest) : void 0;
+		message.configureCtsResponse = object.configureCtsResponse !== void 0 && object.configureCtsResponse !== null ? NeurioMeterAPIConfigureCtsResponse.fromPartial(object.configureCtsResponse) : void 0;
+		message.detectWiredRequest = object.detectWiredRequest !== void 0 && object.detectWiredRequest !== null ? NeurioMeterAPIDetectWiredRequest.fromPartial(object.detectWiredRequest) : void 0;
+		message.detectWiredResponse = object.detectWiredResponse !== void 0 && object.detectWiredResponse !== null ? NeurioMeterAPIDetectWiredResponse.fromPartial(object.detectWiredResponse) : void 0;
+		message.getNeurioCtTypeRequest = object.getNeurioCtTypeRequest !== void 0 && object.getNeurioCtTypeRequest !== null ? NeurioMeterAPIGetNeurioCtTypeRequest.fromPartial(object.getNeurioCtTypeRequest) : void 0;
+		message.getNeurioCtTypeResponse = object.getNeurioCtTypeResponse !== void 0 && object.getNeurioCtTypeResponse !== null ? NeurioMeterAPIGetNeurioCtTypeResponse.fromPartial(object.getNeurioCtTypeResponse) : void 0;
+		message.setNeurioCtTypeRequest = object.setNeurioCtTypeRequest !== void 0 && object.setNeurioCtTypeRequest !== null ? NeurioMeterAPISetNeurioCtTypeRequest.fromPartial(object.setNeurioCtTypeRequest) : void 0;
+		message.setNeurioCtTypeResponse = object.setNeurioCtTypeResponse !== void 0 && object.setNeurioCtTypeResponse !== null ? NeurioMeterAPISetNeurioCtTypeResponse.fromPartial(object.setNeurioCtTypeResponse) : void 0;
+		return message;
+	}
+};
+function isSet(value) {
+	return value !== null && value !== void 0;
+}
+//#endregion
+exports.ConnectorType = ConnectorType;
+exports.NeurioCTConfig = NeurioCTConfig;
+exports.NeurioCTReading = NeurioCTReading;
+exports.NeurioCompatibleMeterType = NeurioCompatibleMeterType;
+exports.NeurioConnectionError = NeurioConnectionError;
+exports.NeurioConnectionStatus = NeurioConnectionStatus;
+exports.NeurioCtConfigRequestStatus = NeurioCtConfigRequestStatus;
+exports.NeurioCtType = NeurioCtType;
+exports.NeurioMeterAPIAddMeterRequest = NeurioMeterAPIAddMeterRequest;
+exports.NeurioMeterAPIAddMeterResponse = NeurioMeterAPIAddMeterResponse;
+exports.NeurioMeterAPIConfigureCtsRequest = NeurioMeterAPIConfigureCtsRequest;
+exports.NeurioMeterAPIConfigureCtsResponse = NeurioMeterAPIConfigureCtsResponse;
+exports.NeurioMeterAPIDetectWiredRequest = NeurioMeterAPIDetectWiredRequest;
+exports.NeurioMeterAPIDetectWiredResponse = NeurioMeterAPIDetectWiredResponse;
+exports.NeurioMeterAPIGetNeurioCtTypeRequest = NeurioMeterAPIGetNeurioCtTypeRequest;
+exports.NeurioMeterAPIGetNeurioCtTypeResponse = NeurioMeterAPIGetNeurioCtTypeResponse;
+exports.NeurioMeterAPIRemoveMeterRequest = NeurioMeterAPIRemoveMeterRequest;
+exports.NeurioMeterAPIRemoveMeterResponse = NeurioMeterAPIRemoveMeterResponse;
+exports.NeurioMeterAPISetNeurioCtTypeRequest = NeurioMeterAPISetNeurioCtTypeRequest;
+exports.NeurioMeterAPISetNeurioCtTypeResponse = NeurioMeterAPISetNeurioCtTypeResponse;
+exports.NeurioMeterConfig = NeurioMeterConfig;
+exports.NeurioMeterConnection = NeurioMeterConnection;
+exports.NeurioMeterInterface = NeurioMeterInterface;
+exports.NeurioMeterMessages = NeurioMeterMessages;
+exports.NeurioMeterReadings = NeurioMeterReadings;
+exports.PowerType = PowerType;
+exports.connectorTypeFromJSON = connectorTypeFromJSON;
+exports.connectorTypeToJSON = connectorTypeToJSON;
+exports.neurioCompatibleMeterTypeFromJSON = neurioCompatibleMeterTypeFromJSON;
+exports.neurioCompatibleMeterTypeToJSON = neurioCompatibleMeterTypeToJSON;
+exports.neurioConnectionErrorFromJSON = neurioConnectionErrorFromJSON;
+exports.neurioConnectionErrorToJSON = neurioConnectionErrorToJSON;
+exports.neurioConnectionStatusFromJSON = neurioConnectionStatusFromJSON;
+exports.neurioConnectionStatusToJSON = neurioConnectionStatusToJSON;
+exports.neurioCtConfigRequestStatusFromJSON = neurioCtConfigRequestStatusFromJSON;
+exports.neurioCtConfigRequestStatusToJSON = neurioCtConfigRequestStatusToJSON;
+exports.neurioCtTypeFromJSON = neurioCtTypeFromJSON;
+exports.neurioCtTypeToJSON = neurioCtTypeToJSON;
+exports.powerTypeFromJSON = powerTypeFromJSON;
+exports.powerTypeToJSON = powerTypeToJSON;
+exports.protobufPackage = protobufPackage;