buildMessage(messageId, bytes) {
        return pb[id_to_type[messageId]].deserializeBinary(bytes);
    }

2023-12-24T09:16:37.803Z [err] [ManagerDrivers] [Driver:esphome-wizard] [PhysicalDevice:vattenfall] [Client] Received an error: TypeError: Cannot read properties of undefined (reading 'deserializeBinary')
    at PlaintextFrameHelper.buildMessage (/app/node_modules/@2colors/esphome-native-api/lib/utils/frameHelper.js:37:42)
    at PlaintextFrameHelper.deserialize (/app/node_modules/@2colors/esphome-native-api/lib/utils/plaintextFrameHelper.js:45:30)
    at PlaintextFrameHelper.onData (/app/node_modules/@2colors/esphome-native-api/lib/utils/plaintextFrameHelper.js:55:36)
    at Socket.<anonymous> (/app/node_modules/@2colors/esphome-native-api/lib/utils/plaintextFrameHelper.js:7:47)
    at Socket.emit (node:events:517:28)
    at addChunk (node:internal/streams/readable:368:12)
    at readableAddChunk (node:internal/streams/readable:341:9)
    at Readable.push (node:internal/streams/readable:278:10)
    at TCP.onStreamRead (node:internal/stream_base_commons:190:23)

     esp: function () {  // currently testing for outgoing signaling 
            espInit();                                                              // start the init sequence
            function espInit() {                                                    // create a new client for every ESP device in the local object
                for (let x = 0; x < cfg.esp.length; x++) {
                    espClient.push(clientNew(x));
                    state.esp.entities.push([]);                                    // create entity array for each ESP device
                    clientConnect(x);
                }
            }
            function clientConnect(x) {                                             // client connection function, ran for each ESP device
                espClient[x].connect();
                espClient[x].on('newEntity', entity => {
                    let exist = 0;
                    for (let e = 0; e < state.esp.entities[x].length; e++) {        // scan for this entity in the entity list
                        if (state.esp.entities[x][e].id == entity.id) exist++;
                    }
                    if (exist == 0)                                                 // dont add this entity if its already in the list 
                        state.esp.entities[x].push({ name: entity.config.objectId, type: entity.type, id: entity.id });
                    log("new esp connected, " + entity.config.objectId, 2);
                    if (entity.type === "Switch") {                                 // if this is a switch, register the emitter
                        //  log("setting entity: " + id + " to " + state, 0, 0)
                        em.on(entity.config.objectId, function (id, state) {        // emitter for this connection 
                            entity.connection.switchCommandService({ key: id, state: state });
                        });
                    }
                    entity.on('state', (data) => {
                        for (let y = 0; y < state.esp.entities[x].length; y++) {
                            if (state.esp.entities[x][y].id == data.key) {          // identify this entity request with local object
                                //     log("esp data: " + state.esp.entities[x][y].name + " state: " + data.state, 2, 0)
                                for (let a = 0; a < state.udp.length; a++) {        // scan all the UDP clients and find which one cares about this entity
                                    for (let b = 0; b < state.udp[a].esp.length; b++) {                 // scan each UDP clients registered ESP entity list
                                        if (state.udp[a].esp[b] == state.esp.entities[x][y].name) {     // if there's a match, send UDP client the data
                                            udp.send("E" + JSON.stringify({ id: state.esp.entities[x][y].name, state: data.state }), state.udp[a].port);
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                    });
                });
                espClient[x].on('error', (error) => {
                    console.log(error);
                    log("ESP module went offline, resetting ESP system", 2, 2);
                    reset();                                                        // if there's a connection problem, start reset sequence
                });
            }
            function clientNew(x) {                                                 // create new object for every ESP device 
                return new Client({
                    host: cfg.esp[x].ip,
                    port: 6053,
                    encryptionKey: cfg.esp[x].key,
                    reconnect: true,
                    reconnectInterval: 2000,
                    pingInterval: 3000,
                    pingAttempts: 3
                })
            }
            function reset() {
                em.emit('ws-disconnect');                                               // close and reset websocket service (because removeAllListeners)
                em.removeAllListeners();                                                // remove all event listeners 
                for (let c = 0; c < espClient.length; c++) espClient[c].disconnect();   // disconnect every client 
                espClient = [];                                                         // delete all client objects 
                setTimeout(() => { espInit(); }, 1000);                                 // reconnect to every device
            }

        },

discovery = new Discovery({interface: '0.0.0.0'});

discovery = new Discovery({interface: '192.168.10.107'});

Error: sendMessage timeout
    at Timeout.<anonymous> (/app/node_modules/@2colors/esphome-native-api/lib/connection.js:201:20)
    at listOnTimeout (node:internal/timers:569:17)
    at process.processTimers (node:internal/timers:512:7)

  - id: heater_4
    platform: template
    name: "Heater 4"
    optimistic: true
    restore_mode: ALWAYS_OFF
    on_turn_on:
      then:
        lambda: !lambda |-
          if (!id(apply_delay_4).is_running()) {
            id(apply_delay_4).execute();
          }
    on_turn_off:
      then:
        lambda: !lambda |-
          if (!id(apply_delay_4).is_running()) {
            id(apply_delay_4).execute();
          }

  - id: relay_1
    platform: gpio
    pin: GPIO16
    disabled_by_default: true
    restore_mode: ALWAYS_OFF
    on_turn_on:
      then:
        - script.execute: max_heating_delay_1
    on_turn_off:
      then:
        - script.stop: max_heating_delay_1

			// Listener for discovered devices
			discovery.on('info', async (message) => {
				try {
					this.log.debug(`Discovery message ${JSON.stringify(message)}`);
				} catch (e) {
					this.log.error(`[deviceDiscovery handler] ${e}`);
				}
			});

			discovery = new Discovery(
				// @ts-ignore Type definition of export is incorrect, according to documentation interface can be set https://github.com/twocolors/esphome-native-api#discovery-1
				{
					interface : this.config.discoveryListeningAddress ? this.config.discoveryListeningAddress: '0.0.0.0'
				});