@willieee802/zigbee-herdsman 0.48.3 → 0.49.1

package/dist/controller/model/device.js

@@ -15,178 +15,298 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const zclTransactionSequenceNumber_1 = __importDefault(require("../helpers/zclTransactionSequenceNumber"));
-const endpoint_1 = __importDefault(require("./endpoint"));
-const entity_1 = __importDefault(require("./entity"));
+exports.Device = exports.InterviewState = void 0;
+const node_assert_1 = __importDefault(require("node:assert"));
 const utils_1 = require("../../utils");
-const Zcl = __importStar(require("../../zspec/zcl"));
-const assert_1 = __importDefault(require("assert"));
-const helpers_1 = require("../helpers");
 const logger_1 = require("../../utils/logger");
+const timeService = __importStar(require("../../utils/timeService"));
+const ZSpec = __importStar(require("../../zspec"));
 const enums_1 = require("../../zspec/enums");
-/**
- * @ignore
- */
-const OneJanuary2000 = new Date('January 01, 2000 00:00:00 UTC+00:00').getTime();
-const NS = 'zh:controller:device';
+const Zcl = __importStar(require("../../zspec/zcl"));
+const Zdo = __importStar(require("../../zspec/zdo"));
+const ota_1 = require("../helpers/ota");
+const zclTransactionSequenceNumber_1 = __importDefault(require("../helpers/zclTransactionSequenceNumber"));
+const endpoint_1 = __importDefault(require("./endpoint"));
+const entity_1 = __importDefault(require("./entity"));
+const NS = "zh:controller:device";
+const INTERVIEW_GENBASIC_ATTRIBUTES = [
+    "modelId",
+    "manufacturerName",
+    "powerSource",
+    "zclVersion",
+    "appVersion",
+    "stackVersion",
+    "hwVersion",
+    "dateCode",
+    "swBuildId",
+];
+var InterviewState;
+(function (InterviewState) {
+    InterviewState["Pending"] = "PENDING";
+    InterviewState["InProgress"] = "IN_PROGRESS";
+    InterviewState["Successful"] = "SUCCESSFUL";
+    InterviewState["Failed"] = "FAILED";
+})(InterviewState || (exports.InterviewState = InterviewState = {}));
 class Device extends entity_1.default {
     databaseID;
+    // biome-ignore lint/style/useNamingConvention: cross-repo impact
     ID;
-    _applicationVersion;
-    _dateCode;
+    #genBasic = {};
     _endpoints;
-    _hardwareVersion;
     _ieeeAddr;
-    _interviewCompleted;
-    _interviewing;
+    _interviewState;
     _lastSeen;
     _manufacturerID;
-    _manufacturerName;
-    _modelID;
     _networkAddress;
-    _powerSource;
-    _softwareBuildID;
-    _stackVersion;
     _type;
-    _zclVersion;
     _linkquality;
     _skipDefaultResponse;
     _customReadResponse;
-    _deleted;
     _lastDefaultResponseSequenceNumber;
     _checkinInterval;
     _pendingRequestTimeout;
     _customClusters = {};
+    _gpSecurityKey;
+    #scheduledOta;
+    #otaInProgress = false;
     // Getters/setters
-    get ieeeAddr() { return this._ieeeAddr; }
-    set ieeeAddr(ieeeAddr) { this._ieeeAddr = ieeeAddr; }
-    get applicationVersion() { return this._applicationVersion; }
-    set applicationVersion(applicationVersion) { this._applicationVersion = applicationVersion; }
-    get endpoints() { return this._endpoints; }
-    get interviewCompleted() { return this._interviewCompleted; }
-    get interviewing() { return this._interviewing; }
-    get lastSeen() { return this._lastSeen; }
-    get manufacturerID() { return this._manufacturerID; }
-    get isDeleted() { return this._deleted; }
-    set type(type) { this._type = type; }
-    get type() { return this._type; }
-    get dateCode() { return this._dateCode; }
-    set dateCode(dateCode) { this._dateCode = dateCode; }
-    set hardwareVersion(hardwareVersion) { this._hardwareVersion = hardwareVersion; }
-    get hardwareVersion() { return this._hardwareVersion; }
-    get manufacturerName() { return this._manufacturerName; }
-    set manufacturerName(manufacturerName) { this._manufacturerName = manufacturerName; }
-    set modelID(modelID) { this._modelID = modelID; }
-    get modelID() { return this._modelID; }
-    get networkAddress() { return this._networkAddress; }
+    get ieeeAddr() {
+        return this._ieeeAddr;
+    }
+    set ieeeAddr(ieeeAddr) {
+        this._ieeeAddr = ieeeAddr;
+    }
+    get applicationVersion() {
+        return this.#genBasic.appVersion;
+    }
+    set applicationVersion(version) {
+        this.#genBasic.appVersion = version;
+    }
+    get endpoints() {
+        return this._endpoints;
+    }
+    get interviewState() {
+        return this._interviewState;
+    }
+    get lastSeen() {
+        return this._lastSeen;
+    }
+    get manufacturerID() {
+        return this._manufacturerID;
+    }
+    get isDeleted() {
+        return Device.deletedDevices.get(this.databaseID)?.has(this.ieeeAddr) ?? false;
+    }
+    set type(type) {
+        this._type = type;
+    }
+    get type() {
+        return this._type;
+    }
+    get dateCode() {
+        return this.#genBasic.dateCode;
+    }
+    set dateCode(code) {
+        this.#genBasic.dateCode = code;
+    }
+    set hardwareVersion(version) {
+        this.#genBasic.hwVersion = version;
+    }
+    get hardwareVersion() {
+        return this.#genBasic.hwVersion;
+    }
+    get manufacturerName() {
+        return this.#genBasic.manufacturerName;
+    }
+    set manufacturerName(name) {
+        this.#genBasic.manufacturerName = name;
+    }
+    set modelID(id) {
+        this.#genBasic.modelId = id;
+    }
+    get modelID() {
+        return this.#genBasic.modelId;
+    }
+    get networkAddress() {
+        return this._networkAddress;
+    }
     set networkAddress(networkAddress) {
+        Device.nwkToIeeeCache.get(this.databaseID)?.delete(this._networkAddress);
         this._networkAddress = networkAddress;
+        Device.nwkToIeeeCache.get(this.databaseID)?.set(this._networkAddress, this.ieeeAddr);
         for (const endpoint of this._endpoints) {
             endpoint.deviceNetworkAddress = networkAddress;
         }
     }
-    get powerSource() { return this._powerSource; }
-    set powerSource(powerSource) {
-        this._powerSource = typeof powerSource === 'number' ? Zcl.POWER_SOURCES[powerSource & ~(1 << 7)] : powerSource;
-    }
-    get softwareBuildID() { return this._softwareBuildID; }
-    set softwareBuildID(softwareBuildID) { this._softwareBuildID = softwareBuildID; }
-    get stackVersion() { return this._stackVersion; }
-    set stackVersion(stackVersion) { this._stackVersion = stackVersion; }
-    get zclVersion() { return this._zclVersion; }
-    set zclVersion(zclVersion) { this._zclVersion = zclVersion; }
-    get linkquality() { return this._linkquality; }
-    set linkquality(linkquality) { this._linkquality = linkquality; }
-    get skipDefaultResponse() { return this._skipDefaultResponse; }
-    set skipDefaultResponse(skipDefaultResponse) { this._skipDefaultResponse = skipDefaultResponse; }
-    get customReadResponse() { return this._customReadResponse; }
-    set customReadResponse(customReadResponse) { this._customReadResponse = customReadResponse; }
-    get checkinInterval() { return this._checkinInterval; }
+    get powerSource() {
+        return this.#genBasic.powerSource ? Zcl.POWER_SOURCES[this.#genBasic.powerSource] : undefined;
+    }
+    set powerSource(source) {
+        if (typeof source === "number") {
+            this.#genBasic.powerSource = source & ~(1 << 7);
+        }
+        else {
+            for (const key in Zcl.POWER_SOURCES) {
+                const val = Zcl.POWER_SOURCES[key];
+                if (val === source) {
+                    this.#genBasic.powerSource = Number(key);
+                    break;
+                }
+            }
+        }
+    }
+    get softwareBuildID() {
+        return this.#genBasic.swBuildId;
+    }
+    set softwareBuildID(id) {
+        this.#genBasic.swBuildId = id;
+    }
+    get stackVersion() {
+        return this.#genBasic.stackVersion;
+    }
+    set stackVersion(version) {
+        this.#genBasic.stackVersion = version;
+    }
+    get zclVersion() {
+        return this.#genBasic.zclVersion;
+    }
+    set zclVersion(version) {
+        this.#genBasic.zclVersion = version;
+    }
+    get linkquality() {
+        return this._linkquality;
+    }
+    set linkquality(linkquality) {
+        this._linkquality = linkquality;
+    }
+    get skipDefaultResponse() {
+        return this._skipDefaultResponse;
+    }
+    set skipDefaultResponse(skipDefaultResponse) {
+        this._skipDefaultResponse = skipDefaultResponse;
+    }
+    get customReadResponse() {
+        return this._customReadResponse;
+    }
+    set customReadResponse(customReadResponse) {
+        this._customReadResponse = customReadResponse;
+    }
+    get checkinInterval() {
+        return this._checkinInterval;
+    }
     set checkinInterval(checkinInterval) {
         this._checkinInterval = checkinInterval;
         this.resetPendingRequestTimeout();
     }
-    get pendingRequestTimeout() { return this._pendingRequestTimeout; }
-    set pendingRequestTimeout(pendingRequestTimeout) { this._pendingRequestTimeout = pendingRequestTimeout; }
-    get customClusters() { return this._customClusters; }
+    get pendingRequestTimeout() {
+        return this._pendingRequestTimeout;
+    }
+    set pendingRequestTimeout(pendingRequestTimeout) {
+        this._pendingRequestTimeout = pendingRequestTimeout;
+    }
+    get customClusters() {
+        return this._customClusters;
+    }
+    get gpSecurityKey() {
+        return this._gpSecurityKey;
+    }
+    get genBasic() {
+        return this.#genBasic;
+    }
+    get scheduledOta() {
+        return this.#scheduledOta;
+    }
+    get otaInProgress() {
+        return this.#otaInProgress;
+    }
     meta;
     // This lookup contains all devices that are queried from the database, this is to ensure that always
     // the same instance is returned.
     static devices = new Map();
-    static ReportablePropertiesMapping = {
-        modelId: { key: 'modelID', set: (v, d) => { d.modelID = v; } },
-        manufacturerName: { key: 'manufacturerName', set: (v, d) => { d.manufacturerName = v; } },
-        powerSource: { key: 'powerSource', set: (v, d) => { d.powerSource = v; } },
-        zclVersion: { key: 'zclVersion', set: (v, d) => { d.zclVersion = v; } },
-        appVersion: { key: 'applicationVersion', set: (v, d) => { d.applicationVersion = v; } },
-        stackVersion: { key: 'stackVersion', set: (v, d) => { d.stackVersion = v; } },
-        hwVersion: { key: 'hardwareVersion', set: (v, d) => { d.hardwareVersion = v; } },
-        dateCode: { key: 'dateCode', set: (v, d) => { d.dateCode = v; } },
-        swBuildId: { key: 'softwareBuildID', set: (v, d) => { d.softwareBuildID = v; } },
-    };
-    constructor(databaseID, ID, type, ieeeAddr, networkAddress, manufacturerID, endpoints, manufacturerName, powerSource, modelID, applicationVersion, stackVersion, zclVersion, hardwareVersion, dateCode, softwareBuildID, interviewCompleted, meta, lastSeen, checkinInterval, pendingRequestTimeout) {
+    static loadedFromDatabase = false;
+    static deletedDevices = new Map();
+    static nwkToIeeeCache = new Map();
+    constructor(databaseID, id, type, ieeeAddr, networkAddress, manufacturerID, endpoints, manufacturerName, powerSource, modelID, applicationVersion, stackVersion, zclVersion, hardwareVersion, dateCode, softwareBuildID, interviewState, meta, lastSeen, checkinInterval, pendingRequestTimeout, gpSecurityKey, scheduledOta) {
         super();
         this.databaseID = databaseID;
-        this.ID = ID;
+        this.ID = id;
         this._type = type;
-        this.ieeeAddr = ieeeAddr;
+        this._ieeeAddr = ieeeAddr;
         this._networkAddress = networkAddress;
         this._manufacturerID = manufacturerID;
         this._endpoints = endpoints;
-        this._manufacturerName = manufacturerName;
-        this._powerSource = powerSource;
-        this._modelID = modelID;
-        this._applicationVersion = applicationVersion;
-        this._stackVersion = stackVersion;
-        this._zclVersion = zclVersion;
-        this.hardwareVersion = hardwareVersion;
-        this._dateCode = dateCode;
-        this._softwareBuildID = softwareBuildID;
-        this._interviewCompleted = interviewCompleted;
-        this._interviewing = false;
+        this.#genBasic.manufacturerName = manufacturerName;
+        this.powerSource = powerSource ?? Zcl.PowerSource.Unknown;
+        this.#genBasic.modelId = modelID;
+        this.#genBasic.appVersion = applicationVersion;
+        this.#genBasic.stackVersion = stackVersion;
+        this.#genBasic.zclVersion = zclVersion;
+        this.#genBasic.hwVersion = hardwareVersion;
+        this.#genBasic.dateCode = dateCode;
+        this.#genBasic.swBuildId = softwareBuildID;
+        this._interviewState = interviewState;
         this._skipDefaultResponse = false;
         this.meta = meta;
         this._lastSeen = lastSeen;
         this._checkinInterval = checkinInterval;
         this._pendingRequestTimeout = pendingRequestTimeout;
+        this._gpSecurityKey = gpSecurityKey;
+        this.#scheduledOta = scheduledOta;
     }
-    createEndpoint(ID) {
-        if (this.getEndpoint(ID)) {
-            throw new Error(`Device '${this.ieeeAddr}' already has an endpoint '${ID}'`);
+    createEndpoint(id) {
+        if (this.getEndpoint(id)) {
+            throw new Error(`Device '${this.ieeeAddr}' already has an endpoint '${id}'`);
         }
-        const endpoint = endpoint_1.default.create(this.databaseID, ID, undefined, undefined, [], [], this.networkAddress, this.ieeeAddr);
+        const endpoint = endpoint_1.default.create(this.databaseID, id, undefined, undefined, [], [], this.networkAddress, this.ieeeAddr);
         this.endpoints.push(endpoint);
         this.save();
         return endpoint;
     }
     changeIeeeAddress(ieeeAddr) {
-        delete Device.devices.get(this.databaseID)[this.ieeeAddr];
+        Device.devices.get(this.databaseID)?.delete(this.ieeeAddr);
         this.ieeeAddr = ieeeAddr;
-        Device.devices.get(this.databaseID)[this.ieeeAddr] = this;
-        this.endpoints.forEach((e) => e.deviceIeeeAddress = ieeeAddr);
+        Device.devices.get(this.databaseID)?.set(this.ieeeAddr, this);
+        Device.nwkToIeeeCache.get(this.databaseID)?.set(this.networkAddress, this.ieeeAddr);
+        for (const ep of this.endpoints) {
+            ep.deviceIeeeAddress = ieeeAddr;
+        }
         this.save();
     }
-    getEndpoint(ID) {
-        return this.endpoints.find((e) => e.ID === ID);
+    getEndpoint(id) {
+        return this.endpoints.find((e) => e.ID === id);
     }
     // There might be multiple endpoints with same DeviceId but it is not supported and first endpoint is returned
     getEndpointByDeviceType(deviceType) {
         const deviceID = Zcl.ENDPOINT_DEVICE_TYPE[deviceType];
         return this.endpoints.find((d) => d.deviceID === deviceID);
     }
+    updateGenBasic(data) {
+        Object.assign(this.#genBasic, data);
+    }
     implicitCheckin() {
-        this.endpoints.forEach(async (e) => e.sendPendingRequests(false));
+        // No need to do anythign in `catch` as `endpoint.sendRequest` already logs failures.
+        Promise.allSettled(this.endpoints.map((e) => e.sendPendingRequests(false))).catch(() => { });
     }
     updateLastSeen() {
         this._lastSeen = Date.now();
@@ -194,147 +314,172 @@ class Device extends entity_1.default {
     resetPendingRequestTimeout() {
         // pendingRequestTimeout can be changed dynamically at runtime, and it is not persisted.
         // Default timeout is one checkin interval in milliseconds.
-        this._pendingRequestTimeout = this._checkinInterval * 1000;
+        this._pendingRequestTimeout = (this._checkinInterval ?? 0) * 1000;
     }
     hasPendingRequests() {
-        return this.endpoints.find(e => e.hasPendingRequests()) !== undefined;
+        return this.endpoints.find((e) => e.hasPendingRequests()) !== undefined;
     }
     async onZclData(dataPayload, frame, endpoint) {
-        // Update reportable properties
-        if (frame.isCluster('genBasic') && (frame.isCommand('readRsp') || frame.isCommand('report'))) {
-            for (const [key, val] of Object.entries(helpers_1.ZclFrameConverter.attributeKeyValue(frame, this.manufacturerID, this.customClusters))) {
-                Device.ReportablePropertiesMapping[key]?.set(val, this);
-            }
-        }
-        // Respond to enroll requests
-        if (frame.header.isSpecific && frame.isCluster('ssIasZone') && frame.isCommand('enrollReq')) {
-            logger_1.logger.debug(`IAS - '${this.ieeeAddr}' responding to enroll response`, NS);
-            const payload = { enrollrspcode: 0, zoneid: 23 };
-            await endpoint.command('ssIasZone', 'enrollRsp', payload, { disableDefaultResponse: true });
-        }
-        // Reponse to read requests
-        if (frame.header.isGlobal && frame.isCommand('read') && !(this._customReadResponse?.(frame, endpoint))) {
-            const time = Math.round(((new Date()).getTime() - OneJanuary2000) / 1000);
-            const attributes = {
-                ...endpoint.clusters,
-                genTime: {
-                    attributes: {
-                        timeStatus: 3, // Time-master + synchronised
-                        time: time,
-                        timeZone: ((new Date()).getTimezoneOffset() * -1) * 60,
-                        localTime: time - (new Date()).getTimezoneOffset() * 60,
-                        lastSetTime: time,
-                        validUntilTime: time + (24 * 60 * 60), // valid for 24 hours
-                    },
-                },
-            };
-            if (frame.cluster.name in attributes) {
-                const response = {};
-                for (const entry of frame.payload) {
-                    if (frame.cluster.hasAttribute(entry.attrId)) {
-                        const name = frame.cluster.getAttribute(entry.attrId).name;
-                        if (name in attributes[frame.cluster.name].attributes) {
+        if (!Device.devices.get(this.databaseID)?.has(this.ieeeAddr)) {
+            // prevent race conditions where device gets deleted during processing
+            return;
+        }
+        if (frame.header.isGlobal) {
+            // Response to read requests
+            if (frame.command.name === "read" && !this._customReadResponse?.(frame, endpoint)) {
+                const attributes = {
+                    ...endpoint.clusters,
+                };
+                const isTimeReadRequest = dataPayload.clusterID === Zcl.Clusters.genTime.ID;
+                if (isTimeReadRequest) {
+                    attributes.genTime = {
+                        attributes: timeService.getTimeClusterAttributes(),
+                    };
+                }
+                if (frame.cluster.name in attributes) {
+                    const response = {};
+                    for (const entry of frame.payload) {
+                        const name = frame.cluster.getAttribute(entry.attrId)?.name;
+                        if (name && name in attributes[frame.cluster.name].attributes) {
                             response[name] = attributes[frame.cluster.name].attributes[name];
                         }
                     }
-                }
-                try {
-                    await endpoint.readResponse(frame.cluster.ID, frame.header.transactionSequenceNumber, response, { srcEndpoint: dataPayload.destinationEndpoint });
-                }
-                catch (error) {
-                    logger_1.logger.error(`Read response to ${this.ieeeAddr} failed`, NS);
+                    try {
+                        await endpoint.readResponse(frame.cluster.ID, frame.header.transactionSequenceNumber, response, {
+                            srcEndpoint: dataPayload.destinationEndpoint,
+                        });
+                    }
+                    catch (error) {
+                        logger_1.logger.error(`Read response to ${this.ieeeAddr} failed (${error.message})`, NS);
+                    }
                 }
             }
         }
-        // Handle check-in from sleeping end devices
-        if (frame.header.isSpecific && frame.isCluster("genPollCtrl") && frame.isCommand("checkin")) {
-            try {
-                if (this.hasPendingRequests() || (this._checkinInterval === undefined)) {
-                    const payload = {
-                        startFastPolling: true,
-                        fastPollTimeout: 0,
-                    };
-                    logger_1.logger.debug(`check-in from ${this.ieeeAddr}: accepting fast-poll`, NS);
-                    await endpoint.command(frame.cluster.ID, 'checkinRsp', payload, { sendPolicy: 'immediate' });
-                    // This is a good time to read the checkin interval if we haven't stored it previously
-                    if (this._checkinInterval === undefined) {
-                        const pollPeriod = await endpoint.read('genPollCtrl', ['checkinInterval'], { sendPolicy: 'immediate' });
-                        this._checkinInterval = pollPeriod.checkinInterval / 4; // convert to seconds
-                        this.resetPendingRequestTimeout();
-                        logger_1.logger.debug(`Request Queue (${this.ieeeAddr}): default expiration timeout set to ${this.pendingRequestTimeout}`, NS);
+        else if (frame.header.isSpecific) {
+            switch (frame.cluster.name) {
+                case "ssIasZone": {
+                    if (frame.command.name === "enrollReq") {
+                        // Respond to enroll requests
+                        logger_1.logger.debug(`IAS - '${this.ieeeAddr}' responding to enroll response`, NS);
+                        await endpoint.command("ssIasZone", "enrollRsp", { enrollrspcode: 0, zoneid: 23 }, { disableDefaultResponse: true });
                     }
-                    await Promise.all(this.endpoints.map(async (e) => e.sendPendingRequests(true)));
-                    // We *must* end fast-poll when we're done sending things. Otherwise
-                    // we cause undue power-drain.
-                    logger_1.logger.debug(`check-in from ${this.ieeeAddr}: stopping fast-poll`, NS);
-                    await endpoint.command(frame.cluster.ID, 'fastPollStop', {}, { sendPolicy: 'immediate' });
+                    break;
                 }
-                else {
-                    const payload = {
-                        startFastPolling: false,
-                        fastPollTimeout: 0,
-                    };
-                    logger_1.logger.debug(`check-in from ${this.ieeeAddr}: declining fast-poll`, NS);
-                    await endpoint.command(frame.cluster.ID, 'checkinRsp', payload, { sendPolicy: 'immediate' });
+                case "genPollCtrl": {
+                    if (frame.command.name === "checkin") {
+                        // Handle check-in from sleeping end devices
+                        try {
+                            if (this.hasPendingRequests() || this._checkinInterval === undefined) {
+                                logger_1.logger.debug(`check-in from ${this.ieeeAddr}: accepting fast-poll`, NS);
+                                await endpoint.command(frame.cluster.name, "checkinRsp", {
+                                    startFastPolling: 1,
+                                    fastPollTimeout: 0,
+                                }, { sendPolicy: "immediate" });
+                                // This is a good time to read the checkin interval if we haven't stored it previously
+                                if (this._checkinInterval === undefined) {
+                                    const pollPeriod = await endpoint.read("genPollCtrl", ["checkinInterval"], { sendPolicy: "immediate" });
+                                    this._checkinInterval = pollPeriod.checkinInterval / 4; // convert to seconds
+                                    this.resetPendingRequestTimeout();
+                                    logger_1.logger.debug(`Request Queue (${this.ieeeAddr}): default expiration timeout set to ${this.pendingRequestTimeout}`, NS);
+                                }
+                                await Promise.all(this.endpoints.map(async (e) => await e.sendPendingRequests(true)));
+                                // We *must* end fast-poll when we're done sending things. Otherwise
+                                // we cause undue power-drain.
+                                logger_1.logger.debug(`check-in from ${this.ieeeAddr}: stopping fast-poll`, NS);
+                                await endpoint.command(frame.cluster.name, "fastPollStop", {}, { sendPolicy: "immediate" });
+                            }
+                            else {
+                                logger_1.logger.debug(`check-in from ${this.ieeeAddr}: declining fast-poll`, NS);
+                                await endpoint.command(frame.cluster.name, "checkinRsp", {
+                                    startFastPolling: 0,
+                                    fastPollTimeout: 0,
+                                }, { sendPolicy: "immediate" });
+                            }
+                        }
+                        catch (error) {
+                            logger_1.logger.error(`Handling of poll check-in from ${this.ieeeAddr} failed (${error.message})`, NS);
+                        }
+                    }
+                    break;
                 }
             }
-            catch (error) {
-                /* istanbul ignore next */
-                logger_1.logger.error(`Handling of poll check-in from ${this.ieeeAddr} failed`, NS);
-            }
         }
         // Send a default response if necessary.
-        const isDefaultResponse = frame.header.isGlobal && frame.command.name === 'defaultRsp';
-        const commandHasResponse = frame.command.hasOwnProperty('response');
+        const isDefaultResponse = frame.header.isGlobal && frame.command.name === "defaultRsp";
+        const commandHasResponse = frame.command.response !== undefined;
         const disableDefaultResponse = frame.header.frameControl.disableDefaultResponse;
-        /* istanbul ignore next */
-        const disableTuyaDefaultResponse = endpoint.getDevice().manufacturerName?.startsWith('_TZ') && process.env['DISABLE_TUYA_DEFAULT_RESPONSE'];
+        /* v8 ignore next */
+        const disableTuyaDefaultResponse = this.manufacturerName?.startsWith("_TZ") && process.env.DISABLE_TUYA_DEFAULT_RESPONSE;
         // Sometimes messages are received twice, prevent responding twice
         const alreadyResponded = this._lastDefaultResponseSequenceNumber === frame.header.transactionSequenceNumber;
-        if (this.type !== 'GreenPower' && !dataPayload.wasBroadcast && !disableDefaultResponse && !isDefaultResponse &&
-            !commandHasResponse && !this._skipDefaultResponse && !alreadyResponded && !disableTuyaDefaultResponse) {
+        if (this.type !== "GreenPower" &&
+            !dataPayload.wasBroadcast &&
+            !disableDefaultResponse &&
+            !isDefaultResponse &&
+            !commandHasResponse &&
+            !this._skipDefaultResponse &&
+            !alreadyResponded &&
+            !disableTuyaDefaultResponse) {
             try {
                 this._lastDefaultResponseSequenceNumber = frame.header.transactionSequenceNumber;
                 // In the ZCL it is not documented what the direction of the default response should be
                 // In https://github.com/Koenkk/zigbee2mqtt/issues/18096 a commandResponse (SERVER_TO_CLIENT)
                 // is send and the device expects a CLIENT_TO_SERVER back.
                 // Previously SERVER_TO_CLIENT was always used.
-                // Therefore for non-global commands we inverse the direction.                
-                const direction = frame.header.isGlobal ? Zcl.Direction.SERVER_TO_CLIENT : (frame.header.frameControl.direction === Zcl.Direction.CLIENT_TO_SERVER
-                    ? Zcl.Direction.SERVER_TO_CLIENT : Zcl.Direction.CLIENT_TO_SERVER);
+                // Therefore for non-global commands we inverse the direction.
+                const direction = frame.header.isGlobal
+                    ? Zcl.Direction.SERVER_TO_CLIENT
+                    : frame.header.frameControl.direction === Zcl.Direction.CLIENT_TO_SERVER
+                        ? Zcl.Direction.SERVER_TO_CLIENT
+                        : Zcl.Direction.CLIENT_TO_SERVER;
                 await endpoint.defaultResponse(frame.command.ID, 0, frame.cluster.ID, frame.header.transactionSequenceNumber, { direction });
             }
             catch (error) {
-                logger_1.logger.error(`Default response to ${this.ieeeAddr} failed`, NS);
+                logger_1.logger.debug(`Default response to ${this.ieeeAddr} failed (${error})`, NS);
             }
         }
     }
     /*
      * CRUD
      */
+    /**
+     * Reset runtime lookups.
+     */
+    static resetCache() {
+        Device.devices.clear();
+        Device.loadedFromDatabase = false;
+        Device.deletedDevices.clear();
+        Device.nwkToIeeeCache.clear();
+    }
     static fromDatabaseEntry(entry, databaseID) {
         const networkAddress = entry.nwkAddr;
         const ieeeAddr = entry.ieeeAddr;
-        const endpoints = Object.values(entry.endpoints).map((e) => {
-            return endpoint_1.default.fromDatabaseRecord(e, networkAddress, ieeeAddr, databaseID);
-        });
-        const meta = entry.meta ? entry.meta : {};
-        if (entry.type === 'Group') {
-            throw new Error('Cannot load device from group');
+        const endpoints = [];
+        for (const id in entry.endpoints) {
+            endpoints.push(endpoint_1.default.fromDatabaseRecord(entry.endpoints[id], networkAddress, ieeeAddr, databaseID));
+        }
+        const meta = entry.meta ?? {};
+        if (entry.type === "Group") {
+            throw new Error("Cannot load device from group");
         }
         // default: no timeout (messages expire immediately after first send attempt)
         let pendingRequestTimeout = 0;
-        if ((endpoints.filter((e) => e.inputClusters.includes(Zcl.Clusters.genPollCtrl.ID))).length > 0) {
+        if (endpoints.filter((e) => e.inputClusters.includes(Zcl.Clusters.genPollCtrl.ID)).length > 0) {
             // default for devices that support genPollCtrl cluster (RX off when idle): 1 day
             pendingRequestTimeout = 86400000;
-            /* istanbul ignore else */
-            if (entry.hasOwnProperty('checkinInterval')) {
-                // if the checkin interval is known, messages expire by default after one checkin interval
-                pendingRequestTimeout = entry.checkinInterval * 1000; // milliseconds
-            }
+        }
+        // always load value from database available (modernExtend.quirkCheckinInterval() exists for devices without genPollCtl)
+        if (entry.checkinInterval !== undefined) {
+            // if the checkin interval is known, messages expire by default after one checkin interval
+            pendingRequestTimeout = entry.checkinInterval * 1000; // milliseconds
         }
         logger_1.logger.debug(`Request Queue (${ieeeAddr}): default expiration timeout set to ${pendingRequestTimeout}`, NS);
-        return new Device(databaseID, entry.id, entry.type, ieeeAddr, networkAddress, entry.manufId, endpoints, entry.manufName, entry.powerSource, entry.modelId, entry.appVersion, entry.stackVersion, entry.zclVersion, entry.hwVersion, entry.dateCode, entry.swBuildId, entry.interviewCompleted, meta, entry.lastSeen || null, entry.checkinInterval, pendingRequestTimeout);
+        // Migrate interviewCompleted to interviewState
+        if (!entry.interviewState) {
+            entry.interviewState = entry.interviewCompleted ? InterviewState.Successful : InterviewState.Failed;
+            logger_1.logger.debug(`Migrated interviewState for '${ieeeAddr}': ${entry.interviewCompleted} -> ${entry.interviewState}`, NS);
+        }
+        return new Device(databaseID, entry.id, entry.type, ieeeAddr, networkAddress, entry.manufId, endpoints, entry.manufName, entry.powerSource, entry.modelId, entry.appVersion, entry.stackVersion, entry.zclVersion, entry.hwVersion, entry.dateCode, entry.swBuildId, entry.interviewState, meta, entry.lastSeen, entry.checkinInterval, pendingRequestTimeout, entry.gpSecurityKey, entry.scheduledOta);
     }
     toDatabaseEntry() {
         const epList = this.endpoints.map((e) => e.ID);
@@ -343,115 +488,161 @@ class Device extends entity_1.default {
             endpoints[endpoint.ID] = endpoint.toDatabaseRecord();
         }
         return {
-            id: this.ID, type: this.type, ieeeAddr: this.ieeeAddr, nwkAddr: this.networkAddress,
-            manufId: this.manufacturerID, manufName: this.manufacturerName, powerSource: this.powerSource,
-            modelId: this.modelID, epList, endpoints, appVersion: this.applicationVersion,
-            stackVersion: this.stackVersion, hwVersion: this.hardwareVersion, dateCode: this.dateCode,
-            swBuildId: this.softwareBuildID, zclVersion: this.zclVersion, interviewCompleted: this.interviewCompleted,
-            meta: this.meta, lastSeen: this.lastSeen, checkinInterval: this.checkinInterval
+            id: this.ID,
+            type: this.type,
+            ieeeAddr: this.ieeeAddr,
+            nwkAddr: this.networkAddress,
+            manufId: this.manufacturerID,
+            manufName: this.manufacturerName,
+            powerSource: this.powerSource,
+            modelId: this.modelID,
+            epList,
+            endpoints,
+            appVersion: this.applicationVersion,
+            stackVersion: this.stackVersion,
+            hwVersion: this.hardwareVersion,
+            dateCode: this.dateCode,
+            swBuildId: this.softwareBuildID,
+            zclVersion: this.zclVersion,
+            /** @deprecated Keep interviewCompleted for backwards compatibility (in case zh gets downgraded) */
+            interviewCompleted: this.interviewState === InterviewState.Successful,
+            interviewState: this.interviewState === InterviewState.InProgress ? InterviewState.Pending : this.interviewState,
+            meta: this.meta,
+            lastSeen: this.lastSeen,
+            checkinInterval: this.checkinInterval,
+            gpSecurityKey: this.gpSecurityKey,
+            scheduledOta: this.scheduledOta,
         };
     }
     save(writeDatabase = true) {
-        entity_1.default.getDatabaseByID(this.databaseID).update(this.toDatabaseEntry(), writeDatabase);
+        entity_1.default.getDatabaseByID(this.databaseID)?.update(this.toDatabaseEntry(), writeDatabase);
     }
     static loadFromDatabaseIfNecessary() {
-        entity_1.default.databases.forEach(database => {
-            if (!Device.devices.get(database.id)) {
-                Device.devices.set(database.id, {});
-                const entries = database.getEntries(['Coordinator', 'EndDevice', 'Router', 'GreenPower', 'Unknown']);
-                for (const entry of entries) {
-                    const device = Device.fromDatabaseEntry(entry, database.id);
-                    Device.devices.get(database.id)[device.ieeeAddr] = device;
+        if (!Device.loadedFromDatabase) {
+            entity_1.default.databases.forEach(database => {
+                if (!Device.devices.has(database.id)) {
+                    Device.devices.set(database.id, new Map());
+                    Device.deletedDevices.set(database.id, new Map());
+                    Device.nwkToIeeeCache.set(database.id, new Map());
+                    const entries = database.getEntriesIterator(['Coordinator', 'EndDevice', 'Router', 'GreenPower', 'Unknown']);
+                    for (const entry of entries) {
+                        const device = Device.fromDatabaseEntry(entry, database.id);
+                        Device.devices.get(database.id).set(device.ieeeAddr, device);
+                        Device.nwkToIeeeCache.get(database.id).set(device.networkAddress, device.ieeeAddr);
+                    }
                 }
-            }
-        });
+            });
+            Device.loadedFromDatabase = true;
+        }
     }
     static find(databaseID, ieeeOrNwkAddress, includeDeleted = false) {
-        return typeof ieeeOrNwkAddress === 'string' ? Device.byIeeeAddr(databaseID, ieeeOrNwkAddress, includeDeleted)
-            : Device.byNetworkAddress(ieeeOrNwkAddress, databaseID, includeDeleted);
+        return typeof ieeeOrNwkAddress === "string"
+            ? Device.byIeeeAddr(databaseID, ieeeOrNwkAddress, includeDeleted)
+            : Device.byNetworkAddress(databaseID, ieeeOrNwkAddress, includeDeleted);
     }
     static byIeeeAddr(databaseID, ieeeAddr, includeDeleted = false) {
         Device.loadFromDatabaseIfNecessary();
-        const device = Device.devices.get(databaseID)[ieeeAddr];
-        return device?._deleted && !includeDeleted ? undefined : device;
+        const device = Device.devices.get(databaseID)?.get(ieeeAddr);
+        return includeDeleted ? (Device.deletedDevices.get(databaseID)?.get(ieeeAddr) ?? device) : device;
     }
-    static byNetworkAddress(networkAddress, databaseID, includeDeleted = false) {
+    static byNetworkAddress(databaseID, networkAddress, includeDeleted = false) {
         Device.loadFromDatabaseIfNecessary();
-        return Object.values(Device.allByDatabaseID(databaseID)).find(d => (includeDeleted || !d._deleted) && d.networkAddress === networkAddress);
+        const ieeeAddr = Device.nwkToIeeeCache.get(databaseID)?.get(networkAddress);
+        return ieeeAddr ? Device.byIeeeAddr(databaseID, ieeeAddr, includeDeleted) : undefined;
     }
-    static byType(type, databaseID) {
+    static byType(databaseID, type) {
         return Device.allByDatabaseID(databaseID).filter(d => d.type === type);
     }
-    static all() {
+    static allByDatabaseID(databaseID) {
         Device.loadFromDatabaseIfNecessary();
-        const devices = [];
-        Device.devices.forEach(deviceDB => {
-            devices.push(...Object.values(deviceDB).filter(d => !d._deleted));
-        });
-        return devices;
+        return Array.from(Device.devices.get(databaseID)?.values() ?? []);
     }
-    static allByDatabaseID(databaseID) {
+    /** Check if a device is explicitly deleted */
+    static isDeletedByIeeeAddr(databaseID, ieeeAddr) {
         Device.loadFromDatabaseIfNecessary();
-        return Object.values(Device.devices.get(databaseID)).filter(d => !d._deleted);
+        return Device.deletedDevices.get(databaseID)?.has(ieeeAddr) ?? false;
     }
-    undelete(interviewCompleted) {
-        (0, assert_1.default)(this._deleted, `Device '${this.ieeeAddr}' is not deleted`);
-        this._deleted = false;
-        this._interviewCompleted = interviewCompleted ?? this._interviewCompleted;
-        entity_1.default.getDatabaseByID(this.databaseID).insert(this.toDatabaseEntry());
+    /** Check if a device is explicitly deleted */
+    static isDeletedByNetworkAddress(databaseID, networkAddress) {
+        Device.loadFromDatabaseIfNecessary();
+        const ieeeAddr = Device.nwkToIeeeCache.get(databaseID)?.get(networkAddress);
+        return ieeeAddr ? Device.deletedDevices.get(databaseID)?.has(ieeeAddr) ?? false : false;
     }
-    static create(type, ieeeAddr, networkAddress, manufacturerID, manufacturerName, powerSource, modelID, interviewCompleted, endpoints, databaseID) {
+    // public static all(): Device[] {
+    //     Device.loadFromDatabaseIfNecessary();
+    //     return Array.from(Device.devices.values());
+    // }
+    static *allIterator(databaseID, predicate) {
         Device.loadFromDatabaseIfNecessary();
+        for (const device of Device.allByDatabaseID(databaseID)) {
+            if (!predicate || predicate(device)) {
+                yield device;
+            }
+        }
+    }
+    undelete() {
+        if (Device.deletedDevices.get(this.databaseID)?.delete(this.ieeeAddr)) {
+            Device.devices.get(this.databaseID)?.set(this.ieeeAddr, this);
+            entity_1.default.getDatabaseByID(this.databaseID)?.insert(this.toDatabaseEntry());
+        }
+        else {
+            throw new Error(`Device '${this.ieeeAddr}' is not deleted`);
+        }
+    }
+    static create(type, ieeeAddr, networkAddress, manufacturerID, manufacturerName, powerSource, modelID, interviewState, gpSecurityKey, databaseID) {
+        Device.loadFromDatabaseIfNecessary();
+        if (Device.devices.get(databaseID)?.has(ieeeAddr)) {
+            throw new Error(`Device with IEEE address '${ieeeAddr}' already exists`);
+        }
         const database = entity_1.default.getDatabaseByID(databaseID);
-        if (Device.devices.get(databaseID)[ieeeAddr] && !Device.devices.get(databaseID)[ieeeAddr]._deleted) {
-            throw new Error(`Device with ieeeAddr '${ieeeAddr}' already exists`);
+        if (!database) {
+            throw new Error(`Database with ID '${databaseID}' not found`);
         }
-        const endpointsMapped = endpoints.map((e) => {
-            return endpoint_1.default.create(databaseID, e.ID, e.profileID, e.deviceID, e.inputClusters, e.outputClusters, networkAddress, ieeeAddr);
-        });
         const ID = database.newID();
-        const device = new Device(databaseID, ID, type, ieeeAddr, networkAddress, manufacturerID, endpointsMapped, manufacturerName, powerSource, modelID, undefined, undefined, undefined, undefined, undefined, undefined, interviewCompleted, {}, null, undefined, 0);
+        const device = new Device(databaseID, ID, type, ieeeAddr, networkAddress, manufacturerID, [], manufacturerName, powerSource, modelID, undefined, undefined, undefined, undefined, undefined, undefined, interviewState, {}, undefined, undefined, 0, gpSecurityKey, undefined);
         database.insert(device.toDatabaseEntry());
-        Device.devices.get(databaseID)[device.ieeeAddr] = device;
+        Device.devices.get(databaseID)?.set(device.ieeeAddr, device);
+        Device.nwkToIeeeCache.get(databaseID)?.set(device.networkAddress, device.ieeeAddr);
         return device;
     }
     /*
      * Zigbee functions
      */
-    async interview() {
-        if (this.interviewing) {
+    async interview(ignoreCache = false) {
+        if (this.interviewState === InterviewState.InProgress) {
             const message = `Interview - interview already in progress for '${this.ieeeAddr}'`;
             logger_1.logger.debug(message, NS);
             throw new Error(message);
         }
-        let error;
-        this._interviewing = true;
+        let err;
+        this._interviewState = InterviewState.InProgress;
         logger_1.logger.debug(`Interview - start device '${this.ieeeAddr}'`, NS);
         try {
-            await this.interviewInternal();
+            await this.interviewInternal(ignoreCache);
             logger_1.logger.debug(`Interview - completed for device '${this.ieeeAddr}'`, NS);
-            this._interviewCompleted = true;
+            this._interviewState = InterviewState.Successful;
         }
-        catch (e) {
+        catch (error) {
             if (this.interviewQuirks()) {
-                logger_1.logger.debug(`Interview - completed for device '${this.ieeeAddr}' because of quirks ('${e}')`, NS);
+                this._interviewState = InterviewState.Successful;
+                logger_1.logger.debug(`Interview - completed for device '${this.ieeeAddr}' because of quirks ('${error}')`, NS);
             }
             else {
-                logger_1.logger.debug(`Interview - failed for device '${this.ieeeAddr}' with error '${e.stack}'`, NS);
-                error = e;
+                this._interviewState = InterviewState.Failed;
+                logger_1.logger.debug(`Interview - failed for device '${this.ieeeAddr}' with error '${error}'`, NS);
+                err = error;
             }
         }
         finally {
-            this._interviewing = false;
             this.save();
         }
-        if (error) {
-            throw error;
+        if (err) {
+            throw err;
         }
     }
     interviewQuirks() {
         logger_1.logger.debug(`Interview - quirks check for '${this.modelID}'-'${this.manufacturerName}'-'${this.type}'`, NS);
-        // TuYa devices are typically hard to interview. They also don't require a full interview to work correctly
+        // Tuya devices are typically hard to interview. They also don't require a full interview to work correctly
         // e.g. no ias enrolling is required for the devices to work.
         // Assume that in case we got both the manufacturerName and modelID the device works correctly.
         // https://github.com/Koenkk/zigbee2mqtt/issues/7564:
@@ -459,61 +650,66 @@ class Device extends entity_1.default {
         // https://github.com/Koenkk/zigbee2mqtt/issues/4655
         //      Device does not change zoneState after enroll (event with original gateway)
         // modelID is mostly in the form of e.g. TS0202 and manufacturerName like e.g. _TYZB01_xph99wvr
-        if (this.modelID?.match('^TS\\d*$') &&
-            (this.manufacturerName?.match('^_TZ.*_.*$') || this.manufacturerName?.match('^_TYZB01_.*$'))) {
-            this._powerSource = this._powerSource || 'Battery';
-            this._interviewing = false;
-            this._interviewCompleted = true;
-            logger_1.logger.debug(`Interview - quirks matched for TuYa end device`, NS);
+        if (this.manufacturerName === "HOBEIAN" ||
+            (this.modelID?.match("^TS\\d*$") && (this.manufacturerName?.match("^_TZ.*_.*$") || this.manufacturerName?.match("^_TYZB01_.*$")))) {
+            this.#genBasic.powerSource = this.#genBasic.powerSource || Zcl.PowerSource.Battery;
+            logger_1.logger.debug("Interview - quirks matched for Tuya end device", NS);
             return true;
         }
         // Some devices, e.g. Xiaomi end devices have a different interview procedure, after pairing they
         // report it's modelID trough a readResponse. The readResponse is received by the controller and set
         // on the device.
         const lookup = {
-            '^3R.*?Z': {
-                type: 'EndDevice', powerSource: 'Battery'
+            "^3R.*?Z": {
+                type: "EndDevice",
+                powerSource: Zcl.PowerSource.Battery,
             },
-            'lumi\..*': {
-                type: 'EndDevice', manufacturerID: 4151, manufacturerName: 'LUMI', powerSource: 'Battery'
+            "lumi..*": {
+                type: "EndDevice",
+                manufacturerID: 4151,
+                manufacturerName: "LUMI",
+                powerSource: Zcl.PowerSource.Battery,
             },
-            'TERNCY-PP01': {
-                type: 'EndDevice', manufacturerID: 4648, manufacturerName: 'TERNCY', powerSource: 'Battery'
+            "TERNCY-PP01": {
+                type: "EndDevice",
+                manufacturerID: 4648,
+                manufacturerName: "TERNCY",
+                powerSource: Zcl.PowerSource.Battery,
             },
-            '3RWS18BZ': {}, // https://github.com/Koenkk/zigbee-herdsman-converters/pull/2710
-            'MULTI-MECI--EA01': {},
-            'MOT003': {}, // https://github.com/Koenkk/zigbee2mqtt/issues/12471
+            "3RWS18BZ": {}, // https://github.com/Koenkk/zigbee-herdsman-converters/pull/2710
+            "MULTI-MECI--EA01": {},
+            MOT003: {}, // https://github.com/Koenkk/zigbee2mqtt/issues/12471
+            "C-ZB-SEDC": {}, //candeo device that doesn't follow IAS enrollment process correctly and therefore fails to complete interview
+            "C-ZB-SEMO": {}, //candeo device that doesn't follow IAS enrollment process correctly and therefore fails to complete interview
+            "CS-T9C-A0-BG": {}, // iAS enroll fails: https://github.com/Koenkk/zigbee2mqtt/issues/27822
+            "SNZB-01": {}, // iAS enroll fails: https://github.com/Koenkk/zigbee2mqtt/issues/29474
         };
-        const match = Object.keys(lookup).find((key) => this.modelID && this.modelID.match(key));
+        let match;
+        for (const key in lookup) {
+            if (this.modelID?.match(key)) {
+                match = key;
+                break;
+            }
+        }
         if (match) {
             const info = lookup[match];
             logger_1.logger.debug(`Interview procedure failed but got modelID matching '${match}', assuming interview succeeded`, NS);
-            this._type = this._type === 'Unknown' ? info.type : this._type;
+            this._type = this._type === "Unknown" && info.type ? info.type : this._type;
             this._manufacturerID = this._manufacturerID || info.manufacturerID;
-            this._manufacturerName = this._manufacturerName || info.manufacturerName;
-            this._powerSource = this._powerSource || info.powerSource;
-            this._interviewing = false;
-            this._interviewCompleted = true;
+            this.#genBasic.manufacturerName = this.#genBasic.manufacturerName || info.manufacturerName;
+            this.#genBasic.powerSource = (this.#genBasic.powerSource || info.powerSource) /* v8 ignore next */ ?? Zcl.PowerSource.Unknown;
             logger_1.logger.debug(`Interview - quirks matched on '${match}'`, NS);
             return true;
         }
-        else {
-            logger_1.logger.debug('Interview - quirks did not match', NS);
-            return false;
-        }
+        logger_1.logger.debug("Interview - quirks did not match", NS);
+        return false;
     }
-    async interviewInternal() {
-        const nodeDescriptorQuery = async () => {
-            const nodeDescriptor = await entity_1.default.getAdapterByID(this.databaseID).nodeDescriptor(this.networkAddress);
-            this._manufacturerID = nodeDescriptor.manufacturerCode;
-            this._type = nodeDescriptor.type;
-            logger_1.logger.debug(`Interview - got node descriptor for device '${this.ieeeAddr}'`, NS);
-        };
-        const hasNodeDescriptor = () => this._manufacturerID != null && this._type != null;
-        if (!hasNodeDescriptor()) {
+    async interviewInternal(ignoreCache) {
+        const hasNodeDescriptor = () => this._manufacturerID !== undefined && this._type !== "Unknown";
+        if (ignoreCache || !hasNodeDescriptor()) {
             for (let attempt = 0; attempt < 6; attempt++) {
                 try {
-                    await nodeDescriptorQuery();
+                    await this.updateNodeDescriptor();
                     break;
                 }
                 catch (error) {
@@ -521,10 +717,8 @@ class Device extends entity_1.default {
                         logger_1.logger.debug(`Interview - completed for device '${this.ieeeAddr}' because of quirks ('${error}')`, NS);
                         return;
                     }
-                    else {
-                        // Most of the times the first node descriptor query fails and the seconds one succeeds.
-                        logger_1.logger.debug(`Interview - node descriptor request failed for '${this.ieeeAddr}', attempt ${attempt + 1}`, NS);
-                    }
+                    // Most of the times the first node descriptor query fails and the seconds one succeeds.
+                    logger_1.logger.debug(`Interview - node descriptor request failed for '${this.ieeeAddr}', attempt ${attempt + 1}`, NS);
                 }
             }
         }
@@ -534,203 +728,389 @@ class Device extends entity_1.default {
         if (!hasNodeDescriptor()) {
             throw new Error(`Interview failed because can not get node descriptor ('${this.ieeeAddr}')`);
         }
-        if (this.manufacturerID === 4619 && this._type === 'EndDevice') {
-            // Give TuYa end device some time to pair. Otherwise they leave immediately.
+        if (this.manufacturerID === 4619 && this._type === "EndDevice") {
+            // Give Tuya end device some time to pair. Otherwise they leave immediately.
             // https://github.com/Koenkk/zigbee2mqtt/issues/5814
-            logger_1.logger.debug("Interview - Detected TuYa end device, waiting 10 seconds...", NS);
-            await (0, utils_1.Wait)(10000);
+            logger_1.logger.debug("Interview - Detected Tuya end device, waiting 10 seconds...", NS);
+            await (0, utils_1.wait)(10000);
         }
-        else if ([0, 4098].includes(this.manufacturerID)) {
-            // Potentially a TuYa device, some sleep fast so make sure to read the modelId and manufacturerName quickly.
+        else if (this.manufacturerID === 0 || this.manufacturerID === 4098) {
+            // Potentially a Tuya device, some sleep fast so make sure to read the modelId and manufacturerName quickly.
             // In case the device responds, the endoint and modelID/manufacturerName are set
             // in controller.onZclOrRawData()
             // https://github.com/Koenkk/zigbee2mqtt/issues/7553
-            logger_1.logger.debug("Interview - Detected potential TuYa end device, reading modelID and manufacturerName...", NS);
+            logger_1.logger.debug("Interview - Detected potential Tuya end device, reading modelID and manufacturerName...", NS);
             try {
                 const endpoint = endpoint_1.default.create(this.databaseID, 1, undefined, undefined, [], [], this.networkAddress, this.ieeeAddr);
-                const result = await endpoint.read('genBasic', ['modelId', 'manufacturerName'], { sendPolicy: 'immediate' });
-                Object.entries(result)
-                    .forEach((entry) => Device.ReportablePropertiesMapping[entry[0]].set(entry[1], this));
+                const result = await endpoint.read("genBasic", ["modelId", "manufacturerName"], { sendPolicy: "immediate" });
+                this.updateGenBasic(result);
             }
             catch (error) {
-                /* istanbul ignore next */
-                logger_1.logger.debug(`Interview - TuYa read modelID and manufacturerName failed (${error})`, NS);
+                logger_1.logger.debug(`Interview - Tuya read modelID and manufacturerName failed (${error})`, NS);
             }
         }
         // e.g. Xiaomi Aqara Opple devices fail to respond to the first active endpoints request, therefore try 2 times
         // https://github.com/Koenkk/zigbee-herdsman/pull/103
-        const adapter = entity_1.default.getAdapterByID(this.databaseID);
-        let activeEndpoints;
+        let gotActiveEndpoints = false;
         for (let attempt = 0; attempt < 2; attempt++) {
             try {
-                activeEndpoints = await adapter.activeEndpoints(this.networkAddress);
+                await this.updateActiveEndpoints();
+                gotActiveEndpoints = true;
                 break;
             }
             catch (error) {
-                logger_1.logger.debug(`Interview - active endpoints request failed for '${this.ieeeAddr}', attempt ${attempt + 1}`, NS);
+                logger_1.logger.debug(`Interview - active endpoints request failed for '${this.ieeeAddr}', attempt ${attempt + 1} (${error})`, NS);
             }
         }
-        if (!activeEndpoints) {
+        if (!gotActiveEndpoints) {
             throw new Error(`Interview failed because can not get active endpoints ('${this.ieeeAddr}')`);
         }
-        // Make sure that the endpoint are sorted.
-        activeEndpoints.endpoints.sort((a, b) => a - b);
-        // Some devices, e.g. TERNCY return endpoint 0 in the active endpoints request.
-        // This is not a valid endpoint number according to the ZCL, requesting a simple descriptor will result
-        // into an error. Therefore we filter it, more info: https://github.com/Koenkk/zigbee-herdsman/issues/82
-        activeEndpoints.endpoints.filter((e) => e !== 0 && !this.getEndpoint(e)).forEach((e) => this._endpoints.push(endpoint_1.default.create(this.databaseID, e, undefined, undefined, [], [], this.networkAddress, this.ieeeAddr)));
         logger_1.logger.debug(`Interview - got active endpoints for device '${this.ieeeAddr}'`, NS);
-        for (const endpointID of activeEndpoints.endpoints.filter((e) => e !== 0)) {
-            const endpoint = this.getEndpoint(endpointID);
-            const simpleDescriptor = await adapter.simpleDescriptor(this.networkAddress, endpoint.ID);
-            endpoint.profileID = simpleDescriptor.profileID;
-            endpoint.deviceID = simpleDescriptor.deviceID;
-            endpoint.inputClusters = simpleDescriptor.inputClusters;
-            endpoint.outputClusters = simpleDescriptor.outputClusters;
+        const coordinator = Device.byType(this.databaseID, "Coordinator")[0];
+        for (const endpoint of this._endpoints) {
+            await endpoint.updateSimpleDescriptor();
             logger_1.logger.debug(`Interview - got simple descriptor for endpoint '${endpoint.ID}' device '${this.ieeeAddr}'`, NS);
-            // Read attributes, nice to have but not required for succesfull pairing as most of the attributes
-            // are not mandatory in ZCL specification.
-            if (endpoint.supportsInputCluster('genBasic')) {
-                for (const [key, item] of Object.entries(Device.ReportablePropertiesMapping)) {
-                    if (!this[item.key]) {
+            // Read attributes
+            // nice to have but not required for successful pairing as most of the attributes are not mandatory in ZCL specification
+            if (endpoint.supportsInputCluster("genBasic")) {
+                for (const key of INTERVIEW_GENBASIC_ATTRIBUTES) {
+                    if (ignoreCache || !this.#genBasic[key]) {
                         try {
                             let result;
                             try {
-                                result = await endpoint.read('genBasic', [key], { sendPolicy: 'immediate' });
+                                result = await endpoint.read("genBasic", [key], { sendPolicy: "immediate" });
                             }
                             catch (error) {
                                 // Reading attributes can fail for many reason, e.g. it could be that device rejoins
                                 // while joining like in:
                                 // https://github.com/Koenkk/zigbee-herdsman-converters/issues/2485.
                                 // The modelID and manufacturerName are crucial for device identification, so retry.
-                                if (item.key === 'modelID' || item.key === 'manufacturerName') {
-                                    logger_1.logger.debug(`Interview - first ${item.key} retrieval attempt failed, retrying after 10 seconds...`, NS);
-                                    await (0, utils_1.Wait)(10000);
-                                    result = await endpoint.read('genBasic', [key], { sendPolicy: 'immediate' });
+                                if (key === "modelId" || key === "manufacturerName") {
+                                    logger_1.logger.debug(`Interview - first ${key} retrieval attempt failed, retrying after 10 seconds...`, NS);
+                                    await (0, utils_1.wait)(10000);
+                                    result = await endpoint.read("genBasic", [key], { sendPolicy: "immediate" });
                                 }
                                 else {
                                     throw error;
                                 }
                             }
-                            item.set(result[key], this);
-                            logger_1.logger.debug(`Interview - got '${item.key}' for device '${this.ieeeAddr}'`, NS);
+                            this.updateGenBasic(result);
+                            logger_1.logger.debug(`Interview - got '${key}' for device '${this.ieeeAddr}'`, NS);
                         }
                         catch (error) {
-                            logger_1.logger.debug(`Interview - failed to read attribute '${item.key}' from endpoint '${endpoint.ID}' (${error})`, NS);
+                            logger_1.logger.debug(`Interview - failed to read attribute '${key}' from endpoint '${endpoint.ID}' (${error})`, NS);
                         }
                     }
                 }
             }
-        }
-        const coordinator = Device.byType('Coordinator', this.databaseID)[0];
-        // Enroll IAS device
-        for (const endpoint of this.endpoints.filter((e) => e.supportsInputCluster('ssIasZone'))) {
-            logger_1.logger.debug(`Interview - IAS - enrolling '${this.ieeeAddr}' endpoint '${endpoint.ID}'`, NS);
-            const stateBefore = await endpoint.read('ssIasZone', ['iasCieAddr', 'zoneState'], { sendPolicy: 'immediate' });
-            logger_1.logger.debug(`Interview - IAS - before enrolling state: '${JSON.stringify(stateBefore)}'`, NS);
-            // Do not enroll when device has already been enrolled
-            if (stateBefore.zoneState !== 1 || stateBefore.iasCieAddr !== coordinator.ieeeAddr) {
-                logger_1.logger.debug(`Interview - IAS - not enrolled, enrolling`, NS);
-                await endpoint.write('ssIasZone', { 'iasCieAddr': coordinator.ieeeAddr }, { sendPolicy: 'immediate' });
-                logger_1.logger.debug(`Interview - IAS - wrote iasCieAddr`, NS);
-                // There are 2 enrollment procedures:
-                // - Auto enroll: coordinator has to send enrollResponse without receiving an enroll request
-                //                this case is handled below.
-                // - Manual enroll: coordinator replies to enroll request with an enroll response.
-                //                  this case in hanled in onZclData().
-                // https://github.com/Koenkk/zigbee2mqtt/issues/4569#issuecomment-706075676
-                await (0, utils_1.Wait)(500);
-                logger_1.logger.debug(`IAS - '${this.ieeeAddr}' sending enroll response (auto enroll)`, NS);
-                const payload = { enrollrspcode: 0, zoneid: 23 };
-                await endpoint.command('ssIasZone', 'enrollRsp', payload, { disableDefaultResponse: true, sendPolicy: 'immediate' });
-                let enrolled = false;
-                for (let attempt = 0; attempt < 20; attempt++) {
-                    await (0, utils_1.Wait)(500);
-                    const stateAfter = await endpoint.read('ssIasZone', ['iasCieAddr', 'zoneState'], { sendPolicy: 'immediate' });
-                    logger_1.logger.debug(`Interview - IAS - after enrolling state (${attempt}): '${JSON.stringify(stateAfter)}'`, NS);
-                    if (stateAfter.zoneState === 1) {
-                        enrolled = true;
-                        break;
+            // Enroll IAS device
+            if (endpoint.supportsInputCluster("ssIasZone")) {
+                logger_1.logger.debug(`Interview - IAS - enrolling '${this.ieeeAddr}' endpoint '${endpoint.ID}'`, NS);
+                const stateBefore = await endpoint.read("ssIasZone", ["iasCieAddr", "zoneState"], { sendPolicy: "immediate" });
+                logger_1.logger.debug(() => `Interview - IAS - before enrolling state: '${JSON.stringify(stateBefore)}'`, NS);
+                // Do not enroll when device has already been enrolled
+                if (stateBefore.zoneState !== 1 || stateBefore.iasCieAddr !== coordinator.ieeeAddr) {
+                    logger_1.logger.debug("Interview - IAS - not enrolled, enrolling", NS);
+                    await endpoint.write("ssIasZone", { iasCieAddr: coordinator.ieeeAddr }, { disableDefaultResponse: true, sendPolicy: "immediate" });
+                    logger_1.logger.debug("Interview - IAS - wrote iasCieAddr", NS);
+                    // There are 2 enrollment procedures:
+                    // - Auto enroll: coordinator has to send enrollResponse without receiving an enroll request
+                    //                this case is handled below.
+                    // - Manual enroll: coordinator replies to enroll request with an enroll response.
+                    //                  this case in hanled in onZclData().
+                    // https://github.com/Koenkk/zigbee2mqtt/issues/4569#issuecomment-706075676
+                    await (0, utils_1.wait)(500);
+                    logger_1.logger.debug(`IAS - '${this.ieeeAddr}' sending enroll response (auto enroll)`, NS);
+                    const payload = { enrollrspcode: 0, zoneid: 23 };
+                    await endpoint.command("ssIasZone", "enrollRsp", payload, { disableDefaultResponse: true, sendPolicy: "immediate" });
+                    let enrolled = false;
+                    for (let attempt = 0; attempt < 20; attempt++) {
+                        await (0, utils_1.wait)(500);
+                        const stateAfter = await endpoint.read("ssIasZone", ["iasCieAddr", "zoneState"], { sendPolicy: "immediate" });
+                        logger_1.logger.debug(() => `Interview - IAS - after enrolling state (${attempt}): '${JSON.stringify(stateAfter)}'`, NS);
+                        if (stateAfter.zoneState === 1) {
+                            enrolled = true;
+                            break;
+                        }
+                    }
+                    if (enrolled) {
+                        logger_1.logger.debug(`Interview - IAS successfully enrolled '${this.ieeeAddr}' endpoint '${endpoint.ID}'`, NS);
+                    }
+                    else {
+                        throw new Error(`Interview failed because of failed IAS enroll (zoneState didn't change ('${this.ieeeAddr}')`);
                     }
-                }
-                if (enrolled) {
-                    logger_1.logger.debug(`Interview - IAS successfully enrolled '${this.ieeeAddr}' endpoint '${endpoint.ID}'`, NS);
                 }
                 else {
-                    throw new Error(`Interview failed because of failed IAS enroll (zoneState didn't change ('${this.ieeeAddr}')`);
+                    logger_1.logger.debug("Interview - IAS - already enrolled, skipping enroll", NS);
                 }
             }
-            else {
-                logger_1.logger.debug(`Interview - IAS - already enrolled, skipping enroll`, NS);
-            }
         }
         // Bind poll control
         try {
-            for (const endpoint of this.endpoints.filter((e) => e.supportsInputCluster('genPollCtrl'))) {
+            for (const endpoint of this.endpoints.filter((e) => e.supportsInputCluster("genPollCtrl"))) {
                 logger_1.logger.debug(`Interview - Poll control - binding '${this.ieeeAddr}' endpoint '${endpoint.ID}'`, NS);
-                await endpoint.bind('genPollCtrl', coordinator.endpoints[0]);
-                const pollPeriod = await endpoint.read('genPollCtrl', ['checkinInterval'], { sendPolicy: 'immediate' });
+                await endpoint.bind("genPollCtrl", coordinator.endpoints[0]);
+                const pollPeriod = await endpoint.read("genPollCtrl", ["checkinInterval"], { sendPolicy: "immediate" });
                 this._checkinInterval = pollPeriod.checkinInterval / 4; // convert to seconds
                 this.resetPendingRequestTimeout();
             }
+            /* v8 ignore start */
         }
         catch (error) {
-            /* istanbul ignore next */
             logger_1.logger.debug(`Interview - failed to bind genPollCtrl (${error})`, NS);
         }
+        /* v8 ignore stop */
+    }
+    async updateNodeDescriptor() {
+        const clusterId = Zdo.ClusterId.NODE_DESCRIPTOR_REQUEST;
+        const adapter = entity_1.default.getAdapterByID(this.databaseID);
+        if (!adapter) {
+            throw new Error(`No adapter found for database ID ${this.databaseID}`);
+        }
+        const zdoPayload = Zdo.Buffalo.buildRequest(adapter.hasZdoMessageOverhead, clusterId, this.networkAddress);
+        const response = await adapter.sendZdo(this.ieeeAddr, this.networkAddress, clusterId, zdoPayload, false);
+        if (!Zdo.Buffalo.checkStatus(response)) {
+            throw new Zdo.StatusError(response[0]);
+        }
+        // TODO: make use of: capabilities.rxOnWhenIdle, maxIncTxSize, maxOutTxSize, serverMask.stackComplianceRevision
+        const nodeDescriptor = response[1];
+        this._manufacturerID = nodeDescriptor.manufacturerCode;
+        switch (nodeDescriptor.logicalType) {
+            case 0x0:
+                this._type = "Coordinator";
+                break;
+            case 0x1:
+                this._type = "Router";
+                break;
+            case 0x2:
+                this._type = "EndDevice";
+                break;
+        }
+        logger_1.logger.debug(`Interview - got node descriptor for device '${this.ieeeAddr}'`, NS);
+        // TODO: define a property on Device for this value (would be good to have it displayed)
+        // log for devices older than 1 from current revision
+        if (nodeDescriptor.serverMask.stackComplianceRevision < ZSpec.ZIGBEE_REVISION - 1) {
+            // always 0 before revision 21 where field was added
+            const rev = nodeDescriptor.serverMask.stackComplianceRevision < 21 ? "pre-21" : nodeDescriptor.serverMask.stackComplianceRevision;
+            logger_1.logger.info(`Device '${this.ieeeAddr}' is only compliant to revision '${rev}' of the Zigbee specification (current revision: ${ZSpec.ZIGBEE_REVISION}).`, NS);
+        }
+    }
+    async updateActiveEndpoints() {
+        const adapter = entity_1.default.getAdapterByID(this.databaseID);
+        if (!adapter) {
+            throw new Error(`No adapter found for database ID ${this.databaseID}`);
+        }
+        const clusterId = Zdo.ClusterId.ACTIVE_ENDPOINTS_REQUEST;
+        const zdoPayload = Zdo.Buffalo.buildRequest(adapter.hasZdoMessageOverhead, clusterId, this.networkAddress);
+        const response = await adapter.sendZdo(this.ieeeAddr, this.networkAddress, clusterId, zdoPayload, false);
+        if (!Zdo.Buffalo.checkStatus(response)) {
+            throw new Zdo.StatusError(response[0]);
+        }
+        const activeEndpoints = response[1];
+        // Make sure that the endpoint are sorted.
+        activeEndpoints.endpointList.sort((a, b) => a - b);
+        for (const endpoint of activeEndpoints.endpointList) {
+            // Some devices, e.g. TERNCY return endpoint 0 in the active endpoints request.
+            // This is not a valid endpoint number according to the ZCL, requesting a simple descriptor will result
+            // into an error. Therefore we filter it, more info: https://github.com/Koenkk/zigbee-herdsman/issues/82
+            if (endpoint !== 0 && !this.getEndpoint(endpoint)) {
+                this._endpoints.push(endpoint_1.default.create(this.databaseID, endpoint, undefined, undefined, [], [], this.networkAddress, this.ieeeAddr));
+            }
+        }
+        // Remove disappeared endpoints (can happen with e.g. custom devices).
+        this._endpoints = this._endpoints.filter((e) => activeEndpoints.endpointList.includes(e.ID));
+    }
+    /**
+     * Request device to advertise its network address.
+     * Note: This does not actually update the device property (if needed), as this is already done with `zdoResponse` event in Controller.
+     */
+    async requestNetworkAddress() {
+        const clusterId = Zdo.ClusterId.NETWORK_ADDRESS_REQUEST;
+        const adapter = entity_1.default.getAdapterByID(this.databaseID);
+        if (!adapter) {
+            throw new Error(`No adapter found for database ID ${this.databaseID}`);
+        }
+        const zdoPayload = Zdo.Buffalo.buildRequest(adapter.hasZdoMessageOverhead, clusterId, this.ieeeAddr, false, 0);
+        await adapter.sendZdo(this.ieeeAddr, ZSpec.BroadcastAddress.RX_ON_WHEN_IDLE, clusterId, zdoPayload, true);
     }
     async removeFromNetwork() {
-        if (this._type === 'GreenPower') {
+        const adapter = entity_1.default.getAdapterByID(this.databaseID);
+        if (!adapter) {
+            throw new Error(`No adapter found for database ID ${this.databaseID}`);
+        }
+        if (this._type === "GreenPower") {
             const payload = {
                 options: 0x002550,
                 srcID: Number(this.ieeeAddr),
             };
-            const frame = Zcl.Frame.create(Zcl.FrameType.SPECIFIC, Zcl.Direction.SERVER_TO_CLIENT, true, null, zclTransactionSequenceNumber_1.default.next(), 'pairing', 33, payload, this.customClusters);
-            await entity_1.default.getAdapterByID(this.databaseID).sendZclFrameToAll(242, frame, 242, enums_1.BroadcastAddress.RX_ON_WHEN_IDLE);
+            const frame = Zcl.Frame.create(Zcl.FrameType.SPECIFIC, Zcl.Direction.SERVER_TO_CLIENT, true, undefined, zclTransactionSequenceNumber_1.default.next(), "pairing", 33, payload, this.customClusters);
+            await adapter.sendZclFrameToAll(242, frame, 242, enums_1.BroadcastAddress.RX_ON_WHEN_IDLE);
+        }
+        else {
+            const clusterId = Zdo.ClusterId.LEAVE_REQUEST;
+            const zdoPayload = Zdo.Buffalo.buildRequest(adapter.hasZdoMessageOverhead, clusterId, this.ieeeAddr, Zdo.LeaveRequestFlags.WITHOUT_REJOIN);
+            const response = await adapter.sendZdo(this.ieeeAddr, this.networkAddress, clusterId, zdoPayload, false);
+            if (!Zdo.Buffalo.checkStatus(response)) {
+                throw new Zdo.StatusError(response[0]);
+            }
         }
-        else
-            await entity_1.default.getAdapterByID(this.databaseID).removeDevice(this.networkAddress, this.ieeeAddr);
         this.removeFromDatabase();
     }
     removeFromDatabase() {
         Device.loadFromDatabaseIfNecessary();
-        const database = entity_1.default.getDatabaseByID(this.databaseID);
         for (const endpoint of this.endpoints) {
             endpoint.removeFromAllGroupsDatabase();
         }
-        if (database.has(this.ID)) {
+        const database = entity_1.default.getDatabaseByID(this.databaseID);
+        if (database?.has(this.ID)) {
             database.remove(this.ID);
         }
-        this._deleted = true;
+        Device.deletedDevices.get(this.databaseID)?.set(this.ieeeAddr, this);
+        Device.devices.get(this.databaseID)?.delete(this.ieeeAddr);
         // Clear all data in case device joins again
-        this._interviewCompleted = false;
-        this._interviewing = false;
+        // Green power devices are never interviewed, keep existing interview state.
+        this._interviewState = this.type === "GreenPower" ? this._interviewState : InterviewState.Pending;
         this.meta = {};
         const newEndpoints = [];
         for (const endpoint of this.endpoints) {
-            newEndpoints.push(endpoint_1.default.create(database.id, endpoint.ID, endpoint.profileID, endpoint.deviceID, endpoint.inputClusters, endpoint.outputClusters, this.networkAddress, this.ieeeAddr));
+            newEndpoints.push(endpoint_1.default.create(this.databaseID, endpoint.ID, endpoint.profileID, endpoint.deviceID, endpoint.inputClusters, endpoint.outputClusters, this.networkAddress, this.ieeeAddr));
         }
         this._endpoints = newEndpoints;
     }
     async lqi() {
-        return entity_1.default.getAdapterByID(this.databaseID).lqi(this.networkAddress);
+        const adapter = entity_1.default.getAdapterByID(this.databaseID);
+        if (!adapter) {
+            throw new Error(`No adapter found for database ID ${this.databaseID}`);
+        }
+        const clusterId = Zdo.ClusterId.LQI_TABLE_REQUEST;
+        const table = [];
+        const request = async (startIndex) => {
+            const zdoPayload = Zdo.Buffalo.buildRequest(adapter.hasZdoMessageOverhead, clusterId, startIndex);
+            const response = await adapter.sendZdo(this.ieeeAddr, this.networkAddress, clusterId, zdoPayload, false);
+            if (!Zdo.Buffalo.checkStatus(response)) {
+                throw new Zdo.StatusError(response[0]);
+            }
+            const result = response[1];
+            table.push(...result.entryList);
+            return [result.neighborTableEntries, result.entryList.length];
+        };
+        let [tableEntries, entryCount] = await request(0);
+        const size = tableEntries;
+        let nextStartIndex = entryCount;
+        while (table.length < size) {
+            [tableEntries, entryCount] = await request(nextStartIndex);
+            nextStartIndex += entryCount;
+        }
+        return table;
     }
     async routingTable() {
-        return entity_1.default.getAdapterByID(this.databaseID).routingTable(this.networkAddress);
+        const adapter = entity_1.default.getAdapterByID(this.databaseID);
+        if (!adapter) {
+            throw new Error(`No adapter found for database ID ${this.databaseID}`);
+        }
+        const clusterId = Zdo.ClusterId.ROUTING_TABLE_REQUEST;
+        const table = [];
+        const request = async (startIndex) => {
+            const zdoPayload = Zdo.Buffalo.buildRequest(adapter.hasZdoMessageOverhead, clusterId, startIndex);
+            const response = await adapter.sendZdo(this.ieeeAddr, this.networkAddress, clusterId, zdoPayload, false);
+            if (!Zdo.Buffalo.checkStatus(response)) {
+                throw new Zdo.StatusError(response[0]);
+            }
+            const result = response[1];
+            table.push(...result.entryList);
+            return [result.routingTableEntries, result.entryList.length];
+        };
+        let [tableEntries, entryCount] = await request(0);
+        const size = tableEntries;
+        let nextStartIndex = entryCount;
+        while (table.length < size) {
+            [tableEntries, entryCount] = await request(nextStartIndex);
+            nextStartIndex += entryCount;
+        }
+        return table;
+    }
+    async bindingTable() {
+        const adapter = entity_1.default.getAdapterByID(this.databaseID);
+        if (!adapter) {
+            throw new Error(`No adapter found for database ID ${this.databaseID}`);
+        }
+        const clusterId = Zdo.ClusterId.BINDING_TABLE_REQUEST;
+        const table = [];
+        const request = async (startIndex) => {
+            const zdoPayload = Zdo.Buffalo.buildRequest(adapter.hasZdoMessageOverhead, clusterId, startIndex);
+            const response = await adapter.sendZdo(this.ieeeAddr, this.networkAddress, clusterId, zdoPayload, false);
+            if (!Zdo.Buffalo.checkStatus(response)) {
+                throw new Zdo.StatusError(response[0]);
+            }
+            const result = response[1];
+            table.push(...result.entryList);
+            return [result.bindingTableEntries, result.entryList.length];
+        };
+        let [tableEntries, entryCount] = await request(0);
+        const size = tableEntries;
+        let nextStartIndex = entryCount;
+        while (table.length < size) {
+            [tableEntries, entryCount] = await request(nextStartIndex);
+            nextStartIndex += entryCount;
+        }
+        for (const ep of this._endpoints) {
+            const newBinds = [];
+            for (const entry of table) {
+                if (entry.sourceEui64 !== this.ieeeAddr || entry.sourceEndpoint !== ep.ID) {
+                    continue;
+                }
+                if (entry.destAddrMode === 0x01) {
+                    newBinds.push({ type: "group", cluster: entry.clusterId, groupID: entry.dest });
+                }
+                else {
+                    newBinds.push({
+                        type: "endpoint",
+                        cluster: entry.clusterId,
+                        deviceIeeeAddress: entry.dest,
+                        endpointID: entry.destEndpoint,
+                    });
+                }
+            }
+            ep.saveBindings(newBinds);
+        }
+        return table;
+    }
+    /**
+     * Clear all the bindings of a device.
+     * Support of this command is optional (only mandatory if device has a binding table).
+     * @param eui64List list of bind entries to match and clear. Send `["0xffffffffffffffff"]` to clear all.
+     */
+    async clearAllBindings(eui64List) {
+        const adapter = entity_1.default.getAdapterByID(this.databaseID);
+        if (!adapter) {
+            throw new Error(`No adapter found for database ID ${this.databaseID}`);
+        }
+        const clusterId = Zdo.ClusterId.CLEAR_ALL_BINDINGS_REQUEST;
+        const zdoPayload = Zdo.Buffalo.buildRequest(adapter.hasZdoMessageOverhead, clusterId, { eui64List });
+        const response = await adapter.sendZdo(this.ieeeAddr, this.networkAddress, clusterId, zdoPayload, false);
+        if (!Zdo.Buffalo.checkStatus(response)) {
+            throw new Zdo.StatusError(response[0]);
+        }
+        if ((eui64List.length === 1 && eui64List[0].toLowerCase() === ZSpec.BLANK_EUI64) ||
+            eui64List.some((eui64) => eui64.toLowerCase() === this.ieeeAddr)) {
+            for (const ep of this._endpoints) {
+                ep.clearBindings();
+            }
+        }
     }
     async ping(disableRecovery = true) {
-        // Zigbee does not have an official pining mechamism. Use a read request
+        // Zigbee does not have an official pinging mechanism. Use a read request
         // of a mandatory basic cluster attribute to keep it as lightweight as
         // possible.
         const endpoint = this.endpoints.find((ep) => ep.inputClusters.includes(0)) ?? this.endpoints[0];
-        await endpoint.read('genBasic', ['zclVersion'], { disableRecovery });
+        await endpoint.read("genBasic", ["zclVersion"], { disableRecovery, sendPolicy: "immediate" });
     }
     addCustomCluster(name, cluster) {
-        (0, assert_1.default)(!([Zcl.Clusters.touchlink.ID, Zcl.Clusters.greenPower.ID].includes(cluster.ID)), 'Overriding of greenPower or touchlink cluster is not supported');
+        (0, node_assert_1.default)(![Zcl.Clusters.touchlink.ID, Zcl.Clusters.greenPower.ID].includes(cluster.ID), "Overriding of greenPower or touchlink cluster is not supported");
         if (Zcl.Utils.isClusterName(name)) {
-            const existingCluster = Zcl.Clusters[name];
+            const existingCluster = this._customClusters[name] ?? Zcl.Clusters[name];
             // Extend existing cluster
-            (0, assert_1.default)(existingCluster.ID === cluster.ID, `Custom cluster ID (${cluster.ID}) should match existing cluster ID (${existingCluster.ID})`);
+            (0, node_assert_1.default)(existingCluster.ID === cluster.ID, `Custom cluster ID (${cluster.ID}) should match existing cluster ID (${existingCluster.ID})`);
             cluster = {
                 ID: cluster.ID,
                 manufacturerCode: cluster.manufacturerCode,
@@ -741,6 +1121,276 @@ class Device extends entity_1.default {
         }
         this._customClusters[name] = cluster;
     }
+    #waitForOtaCommand(endpointId, commandId, transactionSequenceNumber, timeout) {
+        const adapter = entity_1.default.getAdapterByID(this.databaseID);
+        if (!adapter) {
+            throw new Error(`No adapter found for database ID ${this.databaseID}`);
+        }
+        const waiter = adapter.waitFor(this.networkAddress, endpointId, Zcl.FrameType.SPECIFIC, Zcl.Direction.CLIENT_TO_SERVER, transactionSequenceNumber, Zcl.Clusters.genOta.ID, commandId, timeout);
+        const promise = new Promise((resolve, reject) => {
+            waiter.promise.then((payload) => {
+                try {
+                    const frame = Zcl.Frame.fromBuffer(payload.clusterID, payload.header, payload.data, this.customClusters);
+                    resolve(frame);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            }, (error) => reject(error));
+        });
+        return { promise, cancel: waiter.cancel };
+    }
+    async findMatchingOtaImage(source, current, extraMetas) {
+        logger_1.logger.debug(() => `Getting image metadata for ${this.ieeeAddr}...`, NS);
+        const images = await (0, ota_1.getOtaIndex)(source);
+        // NOTE: Officially an image can be determined with a combination of manufacturerCode and imageType.
+        // However several manufacturers do not follow the spec properly.
+        // The index provides the needed extra metadata to prevent mismatches.
+        // e.g. Tuya must match on manufacturerName, Gledopto on modelId...
+        return images.find((i) => i.imageType === current.imageType &&
+            i.manufacturerCode === current.manufacturerCode &&
+            (i.minFileVersion === undefined || current.fileVersion >= i.minFileVersion) &&
+            (i.maxFileVersion === undefined || current.fileVersion <= i.maxFileVersion) &&
+            // let extra metas override the match from this.modelID, same for manufacturerName
+            (!i.modelId || i.modelId === this.modelID || i.modelId === extraMetas.modelId) &&
+            (!i.manufacturerName ||
+                // biome-ignore lint/style/noNonNullAssertion: ignored using `--suppress`
+                i.manufacturerName.includes(this.manufacturerName) ||
+                // biome-ignore lint/style/noNonNullAssertion: ignored using `--suppress`
+                i.manufacturerName.includes(extraMetas.manufacturerName)) &&
+            (!extraMetas.otaHeaderString || i.otaHeaderString === extraMetas.otaHeaderString) &&
+            (i.hardwareVersionMin === undefined ||
+                (current.hardwareVersion !== undefined && current.hardwareVersion >= i.hardwareVersionMin) ||
+                (extraMetas.hardwareVersionMin !== undefined && extraMetas.hardwareVersionMin >= i.hardwareVersionMin)) &&
+            (i.hardwareVersionMax === undefined ||
+                (current.hardwareVersion !== undefined && current.hardwareVersion <= i.hardwareVersionMax) ||
+                (extraMetas.hardwareVersionMax !== undefined && extraMetas.hardwareVersionMax <= i.hardwareVersionMax)));
+    }
+    async #notifyOta(endpoint) {
+        // Some devices (e.g. Insta) take a very long trying to discover the correct coordinator EP for OTA
+        const queryNextImageRequest = this.#waitForOtaCommand(endpoint.ID, Zcl.Clusters.genOta.commands.queryNextImageRequest.ID, undefined, 60000);
+        try {
+            await endpoint.commandResponse("genOta", "imageNotify", { payloadType: 0, queryJitter: 100 }, { sendPolicy: "immediate" });
+            const response = await queryNextImageRequest.promise;
+            return [response.payload, response.header.transactionSequenceNumber];
+        }
+        catch {
+            queryNextImageRequest.cancel();
+            throw new Error(`Device didn't respond to OTA request`);
+        }
+    }
+    /**
+     * If `current` is undefined, will automatically notify and reply to query with `NO_IMAGE_AVAILABLE` (stops device from doing further requests).
+     */
+    async checkOta(source, current, extraMetas, endpoint = this.endpoints.find((e) => e.supportsOutputCluster("genOta"))) {
+        (0, node_assert_1.default)(endpoint !== undefined, `No endpoint found with OTA cluster support for ${this.ieeeAddr}`);
+        if (this.modelID === "PP-WHT-US") {
+            // see https://github.com/Koenkk/zigbee-OTA/pull/14
+            const scenesEndpoint = this.endpoints.find((e) => e.supportsOutputCluster("genScenes"));
+            if (scenesEndpoint !== undefined) {
+                await scenesEndpoint.write("genScenes", { currentGroup: 49502 }, { disableDefaultResponse: true, sendPolicy: "immediate" });
+            }
+        }
+        if (current === undefined) {
+            let queryTsn;
+            [current, queryTsn] = await this.#notifyOta(endpoint);
+            await endpoint.commandResponse("genOta", "queryNextImageResponse", { status: Zcl.Status.NO_IMAGE_AVAILABLE }, undefined, queryTsn);
+        }
+        logger_1.logger.debug(() => `Checking OTA ${this.ieeeAddr} ${source.downgrade ? "downgrade" : "upgrade"} image availability, current=${JSON.stringify(current)}`, NS);
+        if (this.meta.lumiFileVersion &&
+            (this.modelID === "lumi.airrtc.agl001" || this.modelID === "lumi.curtain.acn003" || this.modelID === "lumi.curtain.agl001")) {
+            // The current.fileVersion which comes from the device is wrong.
+            // Use the `lumiFileVersion` which comes from the manuSpecificLumi.attributeReport instead.
+            // https://github.com/Koenkk/zigbee2mqtt/issues/16345#issuecomment-1454835056
+            // https://github.com/Koenkk/zigbee2mqtt/issues/16345 doesn't seem to be needed for all
+            // https://github.com/Koenkk/zigbee2mqtt/issues/15745
+            current = { ...current, fileVersion: this.meta.lumiFileVersion };
+        }
+        const meta = await this.findMatchingOtaImage(source, current, extraMetas);
+        if (!meta) {
+            // no image in repo/URL for specified device
+            return {
+                available: false,
+                current,
+            };
+        }
+        logger_1.logger.debug(() => `OTA ${source.downgrade ? "downgrade" : "upgrade"} image availability for ${this.ieeeAddr}, available=${JSON.stringify(meta)}`, NS);
+        return {
+            available: meta.force ? true : source.downgrade ? current.fileVersion > meta.fileVersion : current.fileVersion < meta.fileVersion,
+            current,
+            availableMeta: meta,
+        };
+    }
+    async updateOta(source, requestPayload, requestTsn, extraMetas, onProgress, dataSettings, endpoint = this.endpoints.find((e) => e.supportsOutputCluster("genOta"))) {
+        (0, node_assert_1.default)(this.#otaInProgress === false, `OTA already in progress for ${this.ieeeAddr}`);
+        (0, node_assert_1.default)(endpoint !== undefined, `No endpoint found with OTA cluster support for ${this.ieeeAddr}`);
+        if (source === undefined) {
+            (0, node_assert_1.default)(this.#scheduledOta !== undefined, `No currently scheduled OTA for ${this.ieeeAddr}`);
+            source = this.#scheduledOta;
+        }
+        this.#otaInProgress = true;
+        // always expected both undefined if one is, but just in case
+        if (requestPayload === undefined || requestTsn === undefined) {
+            try {
+                [requestPayload, requestTsn] = await this.#notifyOta(endpoint);
+            }
+            finally {
+                this.#otaInProgress = false;
+            }
+        }
+        let available = false;
+        let image;
+        if (source.url && !source.url.endsWith(".json")) {
+            // firmware file at `source.url`
+            try {
+                const downloadedFile = await (0, ota_1.getOtaFirmware)(source.url, undefined);
+                image = (0, ota_1.parseOtaImage)(downloadedFile);
+                available = source.downgrade
+                    ? requestPayload.fileVersion > image.header.fileVersion
+                    : requestPayload.fileVersion < image.header.fileVersion;
+                logger_1.logger.debug(() => 
+                // biome-ignore lint/style/noNonNullAssertion: valid from above, won't change after assignment
+                `Parsed image from '${source.url}' for ${this.ieeeAddr}, header=${JSON.stringify(image.header)}`, NS);
+            }
+            catch (error) {
+                logger_1.logger.error(`Failed to parse OTA image from '${source.url}' for ${this.ieeeAddr}, aborting (${error.message})`, NS);
+                // biome-ignore lint/style/noNonNullAssertion: expected valid
+                logger_1.logger.debug(error.stack, NS);
+            }
+        }
+        else {
+            let availableMeta;
+            try {
+                // index file at `source.url` (or undefined to use defaults)
+                ({ available, availableMeta } = await this.checkOta(source, requestPayload, extraMetas, endpoint));
+            }
+            finally {
+                this.#otaInProgress = false;
+            }
+            if (available && availableMeta) {
+                try {
+                    const downloadedFile = await (0, ota_1.getOtaFirmware)(availableMeta.url, availableMeta.sha512);
+                    image = (0, ota_1.parseOtaImage)(downloadedFile);
+                    logger_1.logger.debug(() => 
+                    // biome-ignore lint/style/noNonNullAssertion: valid from above, won't change after assignment
+                    `Parsed image from '${availableMeta.url}' for ${this.ieeeAddr}, header=${JSON.stringify(image.header)}`, NS);
+                }
+                catch (error) {
+                    logger_1.logger.error(`Failed to parse OTA image for ${this.ieeeAddr}, aborting (${error.message})`, NS);
+                    // biome-ignore lint/style/noNonNullAssertion: expected valid
+                    logger_1.logger.debug(error.stack, NS);
+                }
+            }
+            else {
+                logger_1.logger.info(() => `No OTA ${source.downgrade ? "downgrade" : "upgrade"} image currently available for ${this.ieeeAddr}`, NS);
+            }
+        }
+        // reply to `queryNextImageRequest` now that we have the data for it, should trigger image block/page request from device
+        // NOTE: previous code had try/catch wrapping with ignored error, but that doesn't look good (would fail to start OTA from device side)
+        try {
+            await endpoint.commandResponse("genOta", "queryNextImageResponse", image && available
+                ? {
+                    status: Zcl.Status.SUCCESS,
+                    manufacturerCode: image.header.manufacturerCode,
+                    imageType: image.header.imageType,
+                    fileVersion: image.header.fileVersion,
+                    imageSize: image.header.totalImageSize,
+                }
+                : { status: Zcl.Status.NO_IMAGE_AVAILABLE }, undefined, requestTsn);
+        }
+        finally {
+            this.#otaInProgress = false;
+        }
+        if (!image || !available) {
+            this.#otaInProgress = false;
+            return [requestPayload, undefined];
+        }
+        logger_1.logger.debug(() => `Starting OTA update for ${this.ieeeAddr}`, NS);
+        const session = new ota_1.OtaSession(this.ieeeAddr, endpoint, image, onProgress, dataSettings, this.#waitForOtaCommand.bind(this));
+        let endResult;
+        try {
+            endResult = await session.run();
+        }
+        finally {
+            this.#otaInProgress = false;
+        }
+        logger_1.logger.debug(() => `Received upgrade end request for ${this.ieeeAddr}: ${JSON.stringify(endResult.payload)}`, NS);
+        if (endResult.payload.status === Zcl.Status.SUCCESS) {
+            try {
+                const currentTime = timeService.timestampToZigbeeUtcTime(Date.now());
+                await endpoint.commandResponse("genOta", "upgradeEndResponse", {
+                    manufacturerCode: image.header.manufacturerCode,
+                    imageType: image.header.imageType,
+                    fileVersion: image.header.fileVersion,
+                    currentTime,
+                    upgradeTime: currentTime + 1, // TODO: could this tiny offset be a problem for some stacks?
+                }, undefined, endResult.header.transactionSequenceNumber);
+                onProgress(100, 0);
+                logger_1.logger.info(() => `Update of ${this.ieeeAddr} successful (${Math.round((performance.now() - session.startTime) / 1000)} seconds). Waiting for device announce...`, NS);
+                let timer;
+                await new Promise((resolve) => {
+                    const onDeviceAnnounce = () => {
+                        clearTimeout(timer);
+                        logger_1.logger.debug(() => `Received device announce for ${this.ieeeAddr}, OTA update finished.`, NS);
+                        resolve();
+                    };
+                    // force "finished" after given time
+                    timer = setTimeout(() => {
+                        this.removeListener("deviceAnnounce", onDeviceAnnounce);
+                        logger_1.logger.debug(() => `Timed out waiting for device announce for ${this.ieeeAddr}, OTA update considered finished.`, NS);
+                        resolve();
+                    }, 120000 /** consider "done" after timeout even if no announce seen */);
+                    this.once("deviceAnnounce", onDeviceAnnounce);
+                });
+                // only "cancel" possible scheduled OTA when successful
+                this.#scheduledOta = undefined;
+                this.#otaInProgress = false;
+                return [
+                    requestPayload,
+                    {
+                        fieldControl: 0,
+                        manufacturerCode: image.header.manufacturerCode,
+                        imageType: image.header.imageType,
+                        fileVersion: image.header.fileVersion,
+                    },
+                ];
+            }
+            catch (error) {
+                this.#otaInProgress = false;
+                throw new Error(`OTA upgrade end response failed: ${error.message}`);
+            }
+        }
+        else {
+            /**
+             * For other status value received such as INVALID_IMAGE, REQUIRE_MORE_IMAGE, or ABORT,
+             * the upgrade server SHALL not send Upgrade End Response command but it SHALL send default
+             * response command with status of success and it SHALL wait for the client to reinitiate the upgrade process.
+             */
+            try {
+                await endpoint.defaultResponse(Zcl.Clusters.genOta.commands.upgradeEndRequest.ID, Zcl.Status.SUCCESS, Zcl.Clusters.genOta.ID, endResult.header.transactionSequenceNumber);
+            }
+            catch (error) {
+                logger_1.logger.debug(() => `OTA upgrade end request default response for ${this.ieeeAddr} failed: ${error.message}`, NS);
+            }
+            this.#otaInProgress = false;
+            throw new Error(`OTA update of ${this.ieeeAddr} failed with reason: ${Zcl.Status[endResult.payload.status]}`);
+        }
+    }
+    scheduleOta(source) {
+        (0, node_assert_1.default)(this.endpoints.some((e) => e.supportsOutputCluster("genOta")), `No endpoint found with OTA cluster support for ${this.ieeeAddr}`);
+        if (this.#scheduledOta) {
+            logger_1.logger.info(`Previously scheduled OTA update for '${this.ieeeAddr}' was cancelled in favor of new schedule request`, NS);
+        }
+        this.#scheduledOta = source;
+        logger_1.logger.info(`Scheduled OTA update for '${this.ieeeAddr}' on next request from device`, NS);
+    }
+    unscheduleOta() {
+        if (this.#scheduledOta !== undefined) {
+            this.#scheduledOta = undefined;
+            logger_1.logger.info(`Previously scheduled OTA update for '${this.ieeeAddr}' was cancelled`, NS);
+        }
+    }
 }
+exports.Device = Device;
 exports.default = Device;
 //# sourceMappingURL=device.js.map