homebridge-unifi-access 1.9.1 → 1.10.0

package/dist/access-hub.js

@@ -1,6 +1,51 @@
-import { acquireService, validService } from "homebridge-plugin-utils";
+/* Copyright(C) 2019-2025, HJD (https://github.com/hjdhjd). All rights reserved.
+ *
+ * access-hub.ts: Unified hub and reader device class for UniFi Access.
+ */
 import { AccessDevice } from "./access-device.js";
+import { acquireService, validService } from "homebridge-plugin-utils";
 import { AccessReservedNames } from "./access-types.js";
+// Access methods available to us for readers.
+const accessMethods = [
+    { capability: "identity_face_unlock", key: "face", name: "Face Unlock", option: "AccessMethod.Face", subtype: AccessReservedNames.SWITCH_ACCESSMETHOD_FACE },
+    { capability: "hand_wave", key: "wave", name: "Hand Wave", option: "AccessMethod.Hand", subtype: AccessReservedNames.SWITCH_ACCESSMETHOD_HAND },
+    { capability: "mobile_unlock_ver2", key: "bt_button", name: "Mobile", option: "AccessMethod.Mobile", subtype: AccessReservedNames.SWITCH_ACCESSMETHOD_MOBILE },
+    { capability: "nfc_card_easy_provision", key: "nfc", name: "NFC", option: "AccessMethod.NFC", subtype: AccessReservedNames.SWITCH_ACCESSMETHOD_NFC },
+    { capability: "pin_code", key: "pin_code", name: "PIN", option: "AccessMethod.PIN", subtype: AccessReservedNames.SWITCH_ACCESSMETHOD_PIN },
+    { capability: "qr_code", key: "qr_code", name: "QR Code", option: "AccessMethod.QR", subtype: AccessReservedNames.SWITCH_ACCESSMETHOD_QR }
+];
+// Define the dry contact inputs we're interested in for Access hubs.
+const sensorInputs = ["Dps", "Rel", "Ren", "Rex"];
+// Define the sensor wiring. It's a bit convoluted because there's a lot of inconsistency at the API level across device types in Access:
+//   - For UA-ULTRA, we look at rex_button_mode = proxyMode.
+//   - For other models, we look at per-device wiring keys.
+const sensorWiring = {
+    Dps: {
+        proxyMode: "dps",
+        wiring: {
+            "UA-Hub-Door-Mini": ["wiring_state_d1-dps-neg", "wiring_state_d1-dps-pos"],
+            UAH: ["wiring_state_dps-neg", "wiring_state_dps-pos"],
+            UGT: ["wiring_state_gate-dps-neg", "wiring_state_gate-dps-pos"]
+        }
+    },
+    Rel: {
+        wiring: {
+            UAH: ["wiring_state_rel-neg", "wiring_state_rel-pos"]
+        }
+    },
+    Ren: {
+        wiring: {
+            UAH: ["wiring_state_ren-neg", "wiring_state_ren-pos"]
+        }
+    },
+    Rex: {
+        proxyMode: "rex",
+        wiring: {
+            "UA-Hub-Door-Mini": ["wiring_state_d1-button-neg", "wiring_state_d1-button-pos"],
+            UAH: ["wiring_state_rex-neg", "wiring_state_rex-pos"]
+        }
+    }
+};
 export class AccessHub extends AccessDevice {
     _hkLockState;
     doorbellRingRequestId;
@@ -24,10 +69,21 @@ export class AccessHub extends AccessDevice {
     configureHints() {
         // Configure our parent's hints.
         super.configureHints();
-        this.hints.hasDps = this.hasCapability(["dps_alarm", "dps_mode_selectable", "dps_trigger_level"]) && this.hasFeature("Hub.DPS");
+        this.hints.hasWiringDps = ["UA Ultra", "UA Hub", "UA Hub Door Mini"].includes(this.uda.display_model ?? "") && this.hasFeature("Hub.DPS");
+        this.hints.hasWiringRel = ["UA Hub"].includes(this.uda.display_model ?? "") && this.hasFeature("Hub.REL");
+        this.hints.hasWiringRen = ["UA Hub"].includes(this.uda.display_model ?? "") && this.hasFeature("Hub.REN");
+        this.hints.hasWiringRex = ["UA Ultra", "UA Hub", "UA Hub Door Mini"].includes(this.uda.display_model ?? "") && this.hasFeature("Hub.REX");
         this.hints.logDoorbell = this.hasFeature("Log.Doorbell");
         this.hints.logDps = this.hasFeature("Log.DPS");
         this.hints.logLock = this.hasFeature("Log.Lock");
+        this.hints.logRel = this.hasFeature("Log.REL");
+        this.hints.logRen = this.hasFeature("Log.REN");
+        this.hints.logRex = this.hasFeature("Log.REX");
+        // The Ultra has a single terminal input that's selectable between DPS and REX modes. We detect which mode it's operating in, and adjust accordingly. We've
+        // over-engineered this a bit for future-proofing.
+        if (this.uda.display_model === "UA Ultra") {
+            this.checkUltraInputs();
+        }
         return true;
     }
     // Initialize and configure the light accessory for HomeKit.
@@ -45,14 +101,16 @@ export class AccessHub extends AccessDevice {
         }
         // Configure accessory information.
         this.configureInfo();
-        // Configure the lock.
+        // Configure access method switches, if we're a reader device.
+        this.configureAccessMethodSwitches();
+        // Configure the lock, if we're a hub device.
         this.configureLock();
         this.configureLockTrigger();
-        // Configure the doorbell.
+        // Configure the doorbell, if we have one.
         this.configureDoorbell();
         this.configureDoorbellTrigger();
-        // Configure the door position sensor.
-        this.configureDps();
+        // Configure the sensors connected to terminal inputs.
+        this.configureTerminalInputs();
         // Configure MQTT services.
         this.configureMqtt();
         // Listen for events.
@@ -61,6 +119,43 @@ export class AccessHub extends AccessDevice {
         this.controller.events.on("access.remote_view.change", this.listeners["access.remote_view.change"] = this.eventHandler.bind(this));
         return true;
     }
+    // Configure the access method switches for HomeKit.
+    configureAccessMethodSwitches() {
+        for (const accessMethod of accessMethods) {
+            // Validate whether we should have this service enabled.
+            if (!validService(this.accessory, this.hap.Service.Switch, this.hasCapability("is_reader") && this.hasCapability(accessMethod.capability) && this.hasFeature(accessMethod.option), accessMethod.subtype)) {
+                continue;
+            }
+            // Acquire the service.
+            const service = acquireService(this.accessory, this.hap.Service.Switch, this.accessoryName + " " + accessMethod.name, accessMethod.subtype);
+            if (!service) {
+                this.log.error("Unable to add the %s access method switch.", accessMethod.name);
+                continue;
+            }
+            // Retrieve the state when requested.
+            service.getCharacteristic(this.hap.Characteristic.On).onGet(() => Boolean(this.uda.configs?.find(entry => entry.key === accessMethod.key)?.value === "yes"));
+            // Set the state when requested.
+            service.getCharacteristic(this.hap.Characteristic.On).onSet(async (value) => {
+                const entry = this.uda.configs?.find(entry => entry.key === accessMethod.key);
+                let success;
+                if (entry) {
+                    const response = await this.controller.udaApi.retrieve(this.controller.udaApi.getApiEndpoint("device") + "/" + this.id + "/settings", {
+                        body: JSON.stringify([{ key: entry.key, tag: "open_door_mode", value: value ? "yes" : "no" }]),
+                        method: "PUT"
+                    });
+                    success = this.controller.udaApi.responseOk(response?.statusCode);
+                }
+                // If we didn't find the configuration entry or we didn't succeed in setting the value, revert our switch state.
+                if (!success) {
+                    this.log.error("Unable to %s the %s access method.", value ? "activate" : "deactivate", accessMethod.name);
+                    setTimeout(() => service.updateCharacteristic(this.hap.Characteristic.On, !value), 50);
+                }
+            });
+            // Initialize the switch.
+            service.updateCharacteristic(this.hap.Characteristic.On, Boolean(this.uda.configs?.find(entry => entry.key === accessMethod.key)?.value === "yes"));
+        }
+        return true;
+    }
     // Configure the doorbell service for HomeKit.
     configureDoorbell() {
         // Validate whether we should have this service enabled.
@@ -68,7 +163,7 @@ export class AccessHub extends AccessDevice {
             return false;
         }
         // Acquire the service.
-        const service = acquireService(this.hap, this.accessory, this.hap.Service.Doorbell, this.accessoryName, undefined, () => this.log.info("Enabling the doorbell."));
+        const service = acquireService(this.accessory, this.hap.Service.Doorbell, this.accessoryName, undefined, () => this.log.info("Enabling the doorbell."));
         if (!service) {
             this.log.error("Unable to add the doorbell.");
             return false;
@@ -76,33 +171,62 @@ export class AccessHub extends AccessDevice {
         service.setPrimaryService(true);
         return true;
     }
-    // Configure the door position sensor for HomeKit.
-    configureDps() {
-        // Validate whether we should have this service enabled.
-        if (!validService(this.accessory, this.hap.Service.ContactSensor, this.hints.hasDps, AccessReservedNames.CONTACT_DPS)) {
-            return false;
-        }
-        // Acquire the service.
-        const service = acquireService(this.hap, this.accessory, this.hap.Service.ContactSensor, this.accessoryName + " Door Position Sensor", AccessReservedNames.CONTACT_DPS, () => this.log.info("Enabling the door position sensor."));
-        if (!service) {
-            this.log.error("Unable to add the door position sensor.");
-            return false;
+    // Configure our contact sensors for HomeKit. Availability is determined by a combination of hub model, what's been configured on the hub, and feature options.
+    configureTerminalInputs() {
+        const terminalInputs = [
+            { input: "Dps", label: "Door Position Sensor" },
+            { input: "Rel", label: "Remote Release" },
+            { input: "Ren", label: "Request to Enter Sensor" },
+            { input: "Rex", label: "Request to Exit Sensor" }
+        ];
+        for (const { input, label } of terminalInputs) {
+            const hint = ("hasWiring" + input);
+            const reservedId = AccessReservedNames[("CONTACT_" + input.toUpperCase())];
+            const state = ("hub" + input + "State");
+            // Validate whether we should have this service enabled.
+            if (!validService(this.accessory, this.hap.Service.ContactSensor, (hasService) => {
+                if (!this.hints[hint] && hasService) {
+                    this.log.info("Disabling the " + label.toLowerCase() + ".");
+                }
+                return this.hints[hint];
+            }, reservedId)) {
+                continue;
+            }
+            // Acquire the service.
+            const service = acquireService(this.accessory, this.hap.Service.ContactSensor, this.accessoryName + " " + label, reservedId, () => this.log.info("Enabling the " + label.toLowerCase() + "."));
+            if (!service) {
+                this.log.error("Unable to add the " + label.toLowerCase() + ".");
+                continue;
+            }
+            // Initialize the sensor state.
+            service.updateCharacteristic(this.hap.Characteristic.ContactSensorState, this[state]);
+            service.updateCharacteristic(this.hap.Characteristic.StatusActive, !!this.uda.is_online);
+            // If the hub has tamper indicator capabilities, let's reflect that in HomeKit.
+            if (this.hasCapability("tamper_proofing")) {
+                const tamperedEntry = this.uda.configs?.find(entry => entry.key === "tamper_event");
+                if (tamperedEntry) {
+                    service.updateCharacteristic(this.hap.Characteristic.StatusTampered, (tamperedEntry.value === "true") ? this.hap.Characteristic.StatusTampered.TAMPERED :
+                        this.hap.Characteristic.StatusTampered.NOT_TAMPERED);
+                }
+            }
         }
-        // Initialize the light.
-        service.updateCharacteristic(this.hap.Characteristic.ContactSensorState, this.hubDpsState);
         return true;
     }
     // Configure the lock for HomeKit.
     configureLock() {
+        // Validate whether we should have this service enabled.
+        if (!validService(this.accessory, this.hap.Service.LockMechanism, this.hasCapability("is_hub"))) {
+            return false;
+        }
         // Acquire the service.
-        const service = acquireService(this.hap, this.accessory, this.hap.Service.LockMechanism, this.accessoryName);
+        const service = acquireService(this.accessory, this.hap.Service.LockMechanism, this.accessoryName);
         if (!service) {
             this.log.error("Unable to add the lock.");
             return false;
         }
         // Return the lock state.
-        service.getCharacteristic(this.hap.Characteristic.LockCurrentState)?.onGet(() => this.hkLockState);
-        service.getCharacteristic(this.hap.Characteristic.LockTargetState)?.onSet(async (value) => {
+        service.getCharacteristic(this.hap.Characteristic.LockCurrentState).onGet(() => this.hkLockState);
+        service.getCharacteristic(this.hap.Characteristic.LockTargetState).onSet(async (value) => {
             if (!(await this.hubLockCommand(value === this.hap.Characteristic.LockTargetState.SECURED))) {
                 // Revert our target state.
                 setTimeout(() => service.updateCharacteristic(this.hap.Characteristic.LockTargetState, !value), 50);
@@ -124,15 +248,15 @@ export class AccessHub extends AccessDevice {
             return false;
         }
         // Acquire the service.
-        const service = acquireService(this.hap, this.accessory, this.hap.Service.Switch, this.accessoryName + " Doorbell Trigger", AccessReservedNames.SWITCH_DOORBELL_TRIGGER, () => this.log.info("Enabling the doorbell automation trigger."));
+        const service = acquireService(this.accessory, this.hap.Service.Switch, this.accessoryName + " Doorbell Trigger", AccessReservedNames.SWITCH_DOORBELL_TRIGGER, () => this.log.info("Enabling the doorbell automation trigger."));
         if (!service) {
             this.log.error("Unable to add the doorbell automation trigger.");
             return false;
         }
         // Trigger the doorbell.
-        service.getCharacteristic(this.hap.Characteristic.On)?.onGet(() => this.doorbellRingRequestId !== null);
+        service.getCharacteristic(this.hap.Characteristic.On).onGet(() => this.doorbellRingRequestId !== null);
         // The state isn't really user-triggerable. We have no way, currently, to trigger a ring event on the hub.
-        service.getCharacteristic(this.hap.Characteristic.On)?.onSet(() => {
+        service.getCharacteristic(this.hap.Characteristic.On).onSet(() => {
             setTimeout(() => service.updateCharacteristic(this.hap.Characteristic.On, this.doorbellRingRequestId !== null), 50);
         });
         // Initialize the switch.
@@ -143,19 +267,19 @@ export class AccessHub extends AccessDevice {
     // Configure a switch to automate lock and unlock events in HomeKit beyond what HomeKit might allow for a lock service that gets treated as a secure service.
     configureLockTrigger() {
         // Validate whether we should have this service enabled.
-        if (!validService(this.accessory, this.hap.Service.Switch, this.hasFeature("Hub.Lock.Trigger"), AccessReservedNames.SWITCH_LOCK_TRIGGER)) {
+        if (!validService(this.accessory, this.hap.Service.Switch, this.hasCapability("is_hub") && this.hasFeature("Hub.Lock.Trigger"), AccessReservedNames.SWITCH_LOCK_TRIGGER)) {
             return false;
         }
         // Acquire the service.
-        const service = acquireService(this.hap, this.accessory, this.hap.Service.Switch, this.accessoryName + " Lock Trigger", AccessReservedNames.SWITCH_LOCK_TRIGGER, () => this.log.info("Enabling the lock automation trigger."));
+        const service = acquireService(this.accessory, this.hap.Service.Switch, this.accessoryName + " Lock Trigger", AccessReservedNames.SWITCH_LOCK_TRIGGER, () => this.log.info("Enabling the lock automation trigger."));
         if (!service) {
             this.log.error("Unable to add the lock automation trigger.");
             return false;
         }
         // Trigger the doorbell.
-        service.getCharacteristic(this.hap.Characteristic.On)?.onGet(() => this.hkLockState !== this.hap.Characteristic.LockCurrentState.SECURED);
+        service.getCharacteristic(this.hap.Characteristic.On).onGet(() => this.hkLockState !== this.hap.Characteristic.LockCurrentState.SECURED);
         // The state isn't really user-triggerable. We have no way, currently, to trigger a lock or unlock event on the hub.
-        service.getCharacteristic(this.hap.Characteristic.On)?.onSet(async (value) => {
+        service.getCharacteristic(this.hap.Characteristic.On).onSet(async (value) => {
             // If we are on, we are in an unlocked state. If we are off, we are in a locked state.
             if (!(await this.hubLockCommand(!value))) {
                 // Revert our state.
@@ -218,6 +342,23 @@ export class AccessHub extends AccessDevice {
         });
         return true;
     }
+    // Check and validate Ultra inputs with what the user has configured in HomeKit.
+    checkUltraInputs() {
+        for (const input of ["Dps", "Rex"]) {
+            const hint = ("hasWiring" + input);
+            const mode = input.toLowerCase();
+            // Is the mode enabled on the hub?
+            const isEnabled = this.uda.extensions?.[0]?.target_config?.some(entry => (entry.config_key === "rex_button_mode") && entry.config_value === mode);
+            if (this.hints[hint] && !isEnabled) {
+                // The hub has disabled this input.
+                this.hints[hint] = false;
+            }
+            else if (!this.hints[hint] && isEnabled && this.hasFeature("Hub." + input.toUpperCase())) {
+                // The hub has the input enabled, and we want it enabled in HomeKit.
+                this.hints[hint] = true;
+            }
+        }
+    }
     // Utility function to execute lock and unlock actions on a hub.
     async hubLockCommand(isLocking) {
         const action = isLocking ? "lock" : "unlock";
@@ -238,16 +379,6 @@ export class AccessHub extends AccessDevice {
         }
         return true;
     }
-    // Return the current HomeKit DPS state that we are tracking for this hub.
-    get hkDpsState() {
-        return this.accessory.getService(this.hap.Service.ContactSensor)?.getCharacteristic(this.hap.Characteristic.ContactSensorState).value ??
-            this.hap.Characteristic.ContactSensorState.CONTACT_NOT_DETECTED;
-    }
-    // Set the current HomeKit DPS state for this hub.
-    set hkDpsState(value) {
-        // Update the state of the contact service.
-        this.accessory.getService(this.hap.Service.ContactSensor)?.updateCharacteristic(this.hap.Characteristic.ContactSensorState, value);
-    }
     // Return the current HomeKit lock state that we are tracking for this hub.
     get hkLockState() {
         return this._hkLockState;
@@ -274,7 +405,7 @@ export class AccessHub extends AccessDevice {
     // Return the current state of the DPS on the hub.
     get hubDpsState() {
         // If we don't have the wiring connected for the DPS, we report our default closed state.
-        if (this.isDpsWired) {
+        if (!this.isDpsWired) {
             return this.hap.Characteristic.ContactSensorState.CONTACT_DETECTED;
         }
         let relayType;
@@ -283,12 +414,15 @@ export class AccessHub extends AccessDevice {
             case "UA-ULTRA":
                 relayType = "input_d1_dps";
                 break;
+            case "UGT":
+                relayType = "input_gate_dps";
+                break;
             default:
                 relayType = "input_state_dps";
                 break;
         }
         // Return our DPS state. If it's anything other than on, we assume it's open.
-        return (this.uda.configs?.find(x => x.key === relayType)?.value === "on") ? this.hap.Characteristic.ContactSensorState.CONTACT_DETECTED :
+        return (this.uda.configs?.find(entry => entry.key === relayType)?.value === "on") ? this.hap.Characteristic.ContactSensorState.CONTACT_DETECTED :
             this.hap.Characteristic.ContactSensorState.CONTACT_NOT_DETECTED;
     }
     // Return the current state of the relay lock on the hub.
@@ -299,35 +433,109 @@ export class AccessHub extends AccessDevice {
             case "UA-ULTRA":
                 relayType = "output_d1_lock_relay";
                 break;
+            case "UGT":
+                relayType = "output_oper1_relay";
+                break;
             default:
                 relayType = "input_state_rly-lock_dry";
                 break;
         }
-        const lockRelay = this.uda.configs?.find(x => x.key === relayType);
-        return ((lockRelay?.value === "off") ? this.hap.Characteristic.LockCurrentState.SECURED : this.hap.Characteristic.LockCurrentState.UNSECURED) ??
-            this.hap.Characteristic.LockCurrentState.UNKNOWN;
+        const lockRelay = this.uda.configs?.find(entry => entry.key === relayType);
+        return (lockRelay?.value === "off") ? this.hap.Characteristic.LockCurrentState.SECURED : this.hap.Characteristic.LockCurrentState.UNSECURED;
+    }
+    // Return the current state of the REL on the hub.
+    get hubRelState() {
+        // If we don't have the wiring connected for the REL, we report our default closed state.
+        if (!this.isRelWired) {
+            return this.hap.Characteristic.ContactSensorState.CONTACT_DETECTED;
+        }
+        let relayType;
+        switch (this.uda.device_type) {
+            case "UAH":
+                relayType = "input_state_rel";
+                break;
+            default:
+                return this.hap.Characteristic.ContactSensorState.CONTACT_DETECTED;
+        }
+        // Return our REL state. If it's anything other than on, we assume it's open.
+        return (this.uda.configs?.find(relay => relay.key === relayType)?.value === "on") ? this.hap.Characteristic.ContactSensorState.CONTACT_DETECTED :
+            this.hap.Characteristic.ContactSensorState.CONTACT_NOT_DETECTED;
+    }
+    // Return the current state of the REN on the hub.
+    get hubRenState() {
+        // If we don't have the wiring connected for the REN, we report our default closed state.
+        if (!this.isRenWired) {
+            return this.hap.Characteristic.ContactSensorState.CONTACT_DETECTED;
+        }
+        let relayType;
+        switch (this.uda.device_type) {
+            case "UAH":
+                relayType = "input_state_ren";
+                break;
+            default:
+                return this.hap.Characteristic.ContactSensorState.CONTACT_DETECTED;
+        }
+        // Return our REN state. If it's anything other than on, we assume it's open.
+        return (this.uda.configs?.find(relay => relay.key === relayType)?.value === "on") ? this.hap.Characteristic.ContactSensorState.CONTACT_DETECTED :
+            this.hap.Characteristic.ContactSensorState.CONTACT_NOT_DETECTED;
     }
-    // Return whether the DPS has been wired on the hub.
-    get isDpsWired() {
-        let wiringType = [];
+    // Return the current state of the REX on the hub.
+    get hubRexState() {
+        // If we don't have the wiring connected for the REX, we report our default closed state.
+        if (!this.isRexWired) {
+            return this.hap.Characteristic.ContactSensorState.CONTACT_DETECTED;
+        }
+        let relayType;
         switch (this.uda.device_type) {
             case "UA-Hub-Door-Mini":
             case "UA-ULTRA":
-                wiringType = ["wiring_state_d1-dps-neg", "wiring_state_d1-dps-pos"];
+                relayType = "input_d1_button";
                 break;
-            default:
-                wiringType = ["wiring_state_dps-neg", "wiring_state_dps-pos"];
+            case "UAH":
+                relayType = "input_state_rex";
                 break;
+            default:
+                return this.hap.Characteristic.ContactSensorState.CONTACT_DETECTED;
+        }
+        // Return our REX state. If it's anything other than on, we assume it's open.
+        return (this.uda.configs?.find(relay => relay.key === relayType)?.value === "on") ? this.hap.Characteristic.ContactSensorState.CONTACT_DETECTED :
+            this.hap.Characteristic.ContactSensorState.CONTACT_NOT_DETECTED;
+    }
+    // Utility to check the wiring state of a given terminal input.
+    isWired(input) {
+        // UA-ULTRA proxies via button mode.
+        if ((this.uda.device_type === "UA-ULTRA") && sensorWiring[input].proxyMode) {
+            return this.uda.extensions?.[0]?.target_config?.some(e => e.config_key === "rex_button_mode" && e.config_value === sensorWiring[input].proxyMode) ?? false;
+        }
+        // Find the wiring keys for this model.
+        const wires = sensorWiring[input].wiring?.[this.uda.device_type];
+        if (!wires) {
+            return false;
         }
-        // The DPS is considered wired only if all associated wiring is connected.
-        return wiringType.filter(wire => this.uda.configs?.some(x => x.key === wire && x.value === "on")).length === wiringType.length;
+        // All wires must be on for us to return true.
+        return wires.every(wire => this.uda.configs?.some(e => (e.key === wire) && (e.value === "on")));
+    }
+    // Utility to retrieve a contact sensor state.
+    getContactSensorState(name) {
+        return this.accessory.getServiceById(this.hap.Service.ContactSensor, name)?.getCharacteristic(this.hap.Characteristic.ContactSensorState).value ??
+            this.hap.Characteristic.ContactSensorState.CONTACT_NOT_DETECTED;
+    }
+    // Utility to set a contact sensor state.
+    setContactSensorState(name, value) {
+        this.accessory.getServiceById(this.hap.Service.ContactSensor, name)?.updateCharacteristic(this.hap.Characteristic.ContactSensorState, value);
     }
     // Utility to validate hub capabilities.
     hasCapability(capability) {
-        return Array.isArray(capability) ? capability.some(c => this.uda?.capabilities?.includes(c)) : this.uda?.capabilities?.includes(capability);
+        return Array.isArray(capability) ? capability.some(c => this.uda.capabilities.includes(c)) : this.uda.capabilities.includes(capability);
     }
     // Handle hub-related events.
     eventHandler(packet) {
+        const terminalInputs = [
+            { input: "Dps", label: "Door position sensor", topic: "dps" },
+            { input: "Rel", label: "Remote release", topic: "rel" },
+            { input: "Ren", label: "Request to enter sensor", topic: "ren" },
+            { input: "Rex", label: "Request to exit sensor", topic: "rex" }
+        ];
         switch (packet.event) {
             case "access.data.device.remote_unlock":
                 // Process an Access unlock event.
@@ -347,15 +555,49 @@ export class AccessHub extends AccessDevice {
                         this.log.info(this.hkLockState === this.hap.Characteristic.LockCurrentState.SECURED ? "Locked." : "Unlocked.");
                     }
                 }
-                // Process a DPS update event if our state has changed.
-                if (this.hints.hasDps && (this.hubDpsState !== this.hkDpsState)) {
-                    this.hkDpsState = this.hubDpsState;
-                    // Publish to MQTT, if configured to do so.
-                    if (this.isDpsWired) {
-                        this.controller.mqtt?.publish(this.id, "dps", (this.hkDpsState === this.hap.Characteristic.ContactSensorState.CONTACT_DETECTED) ? "false" : "true");
-                        if (this.hints.logDps) {
-                            this.log.info("Door position sensor " + ((this.hkDpsState === this.hap.Characteristic.ContactSensorState.CONTACT_DETECTED) ? "closed." : "open."));
+                // Process any terminal input update events if our state has changed.
+                for (const { input, topic, label } of terminalInputs) {
+                    const hasKey = ("hasWiring" + input);
+                    const hkKey = ("hk" + input + "State");
+                    const hubKey = ("hub" + input + "State");
+                    const logKey = ("log" + input);
+                    const wiredKey = ("is" + input + "Wired");
+                    if (this.hints[hasKey] && this[hubKey] !== this[hkKey]) {
+                        this[hkKey] = this[hubKey];
+                        if (this[wiredKey]) {
+                            const contactDetected = this[hkKey] === this.hap.Characteristic.ContactSensorState.CONTACT_DETECTED;
+                            this.controller.mqtt?.publish(this.id, topic, contactDetected ? "false" : "true");
+                            if (this.hints[logKey]) {
+                                this.log.info(label + " " + (contactDetected ? "closed" : "open") + ".");
+                            }
+                        }
+                    }
+                }
+                // Process any changes to terminal input configuration.
+                if (packet.data.extensions?.[0]?.target_config && (this.uda.display_model === "UA Ultra")) {
+                    // Ensure we sync our state with HomeKit.
+                    this.checkUltraInputs();
+                    this.configureTerminalInputs();
+                }
+                // Process any changes to our online status.
+                if (packet.data.is_online !== undefined) {
+                    for (const sensor of Object.keys(AccessReservedNames).filter(key => key.startsWith("CONTACT_"))) {
+                        this.accessory.getServiceById(this.hap.Service.ContactSensor, AccessReservedNames[sensor])?.
+                            updateCharacteristic(this.hap.Characteristic.StatusActive, !!packet.data.is_online);
+                    }
+                }
+                break;
+            case "access.data.v2.device.update":
+                if (packet.data.access_method) {
+                    const accessMethodData = packet.data.access_method;
+                    // Process access method updates.
+                    for (const [key, value] of Object.entries(accessMethodData)) {
+                        const accessMethod = accessMethods.find(entry => entry.key === key);
+                        if (!accessMethod) {
+                            continue;
                         }
+                        // Update any access method switches we have enabled with the current value.
+                        this.accessory.getServiceById(this.hap.Service.Switch, accessMethod.subtype)?.updateCharacteristic(this.hap.Characteristic.On, value === "yes");
                     }
                 }
                 break;
@@ -394,5 +636,34 @@ export class AccessHub extends AccessDevice {
                 break;
         }
     }
+    // We dynamically define our getters and setters for terminal inputs so we can streamline redundancies. Yes, this is fancy...but it's meant to future-proof a bit
+    // against whatever Ubiquiti may do in the future given the inconsistencies in their API implementation for Access across devices of even similar types.
+    static {
+        // We define the specific sensor input properties we need.
+        for (const input of sensorInputs) {
+            let propName = "hk" + input + "State";
+            const enumKey = "CONTACT_" + input.toUpperCase();
+            Object.defineProperty(AccessHub.prototype, propName, {
+                configurable: true,
+                enumerable: true,
+                get() {
+                    // Delegate to our individual helper functions.
+                    return this.getContactSensorState(AccessReservedNames[enumKey]);
+                },
+                set(value) {
+                    this.setContactSensorState(AccessReservedNames[enumKey], value);
+                }
+            });
+            // Now define our wiring getters.
+            propName = "is" + input + "Wired";
+            Object.defineProperty(AccessHub.prototype, propName, {
+                configurable: true,
+                enumerable: true,
+                get() {
+                    return this.isWired(input);
+                }
+            });
+        }
+    }
 }
 //# sourceMappingURL=access-hub.js.map