homebridge-unifi-access 1.10.1 → 1.11.0

package/dist/access-hub.js

@@ -1,4 +1,4 @@
-/* Copyright(C) 2019-2025, HJD (https://github.com/hjdhjd). All rights reserved.
+/* Copyright(C) 2019-2026, HJD (https://github.com/hjdhjd). All rights reserved.
  *
  * access-hub.ts: Unified hub and reader device class for UniFi Access.
  */
@@ -46,17 +46,34 @@ const sensorWiring = {
         }
     }
 };
+// Constants for timing.
+const AUTO_LOCK_DELAY_MS = 5000;
+const GATE_TRANSITION_COOLDOWN_MS = 5000;
 export class AccessHub extends AccessDevice {
+    _hkDpsState;
     _hkLockState;
+    _hkSideDoorDpsState;
+    _hkSideDoorLockState;
     doorbellRingRequestId;
+    gateTransitionUntil;
     lockDelayInterval;
+    mainDoorLocationId;
+    sideDoorLocationId;
+    sideDoorGateTransitionUntil;
     uda;
     // Create an instance.
     constructor(controller, device, accessory) {
         super(controller, accessory);
         this.uda = device;
+        this._hkDpsState = this.hubDpsState;
         this._hkLockState = this.hubLockState;
+        this._hkSideDoorDpsState = this.hubSideDoorDpsState;
+        this._hkSideDoorLockState = this.hubSideDoorLockState;
+        this.gateTransitionUntil = 0;
         this.lockDelayInterval = this.getFeatureNumber("Hub.LockDelayInterval") ?? undefined;
+        this.mainDoorLocationId = undefined;
+        this.sideDoorLocationId = undefined;
+        this.sideDoorGateTransitionUntil = 0;
         this.doorbellRingRequestId = null;
         // If we attempt to set the delay interval to something invalid, then assume we are using the default unlock behavior.
         if ((this.lockDelayInterval !== undefined) && (this.lockDelayInterval < 0)) {
@@ -69,10 +86,12 @@ export class AccessHub extends AccessDevice {
     configureHints() {
         // Configure our parent's hints.
         super.configureHints();
-        this.hints.hasWiringDps = ["UA Ultra", "UA Hub", "UA Hub Door Mini"].includes(this.uda.display_model ?? "") && this.hasFeature("Hub.DPS");
+        this.hints.hasSideDoor = (this.uda.device_type === "UGT") && this.hasFeature("Hub.SideDoor");
+        this.hints.hasWiringDps = ["UA Ultra", "UA Hub", "UA Hub Door Mini", "UA Gate"].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.hasWiringSideDoorDps = this.hints.hasSideDoor && this.hasFeature("Hub.SideDoor.DPS");
         this.hints.logDoorbell = this.hasFeature("Log.Doorbell");
         this.hints.logDps = this.hasFeature("Log.DPS");
         this.hints.logLock = this.hasFeature("Log.Lock");
@@ -86,9 +105,115 @@ export class AccessHub extends AccessDevice {
         }
         return true;
     }
+    // Return the door service type from configuration. UA Gate devices default to GarageDoorOpener and can be overridden to Lock. Other hubs default to Lock and can be
+    // overridden to GarageDoorOpener.
+    get doorServiceType() {
+        if (this.uda.device_type === "UGT") {
+            return this.hasFeature("Hub.Door.UseLock") ? "Lock" : "GarageDoorOpener";
+        }
+        return this.hasFeature("Hub.Door.UseGarageOpener") ? "GarageDoorOpener" : "Lock";
+    }
+    // Convert lock string value to HomeKit LockCurrentState.
+    toLockState(lockValue) {
+        return ["unlock", "unlocked"].includes(lockValue) ? this.hap.Characteristic.LockCurrentState.UNSECURED : this.hap.Characteristic.LockCurrentState.SECURED;
+    }
+    // Convert DPS string value to HomeKit ContactSensorState.
+    toDpsState(dpsValue) {
+        return dpsValue === "open" ? this.hap.Characteristic.ContactSensorState.CONTACT_NOT_DETECTED : this.hap.Characteristic.ContactSensorState.CONTACT_DETECTED;
+    }
+    // Check if a lock state represents "locked".
+    isLocked(state) {
+        return state === this.hap.Characteristic.LockCurrentState.SECURED;
+    }
+    // Check if a DPS state represents "closed" (contact detected).
+    isClosed(state) {
+        return state === this.hap.Characteristic.ContactSensorState.CONTACT_DETECTED;
+    }
+    // Discover main and side door location IDs for UA Gate hubs. This allows us to receive remote_unlock events for each door.
+    discoverDoorIds() {
+        const doors = this.controller.udaApi.doors ?? [];
+        if (doors.length === 0) {
+            this.log.warn("No doors found in Access API. Door event handling may not work correctly.");
+            return;
+        }
+        // Get the primary door ID from device config (may be undefined).
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        const primaryDoorId = this.uda.door?.unique_id;
+        // Strategy 1: Use the device's bound door as main door.
+        if (primaryDoorId) {
+            this.mainDoorLocationId = primaryDoorId;
+        }
+        else if (doors.length >= 1) {
+            // Strategy 2: Look for a door named like "main", "gate", "portail" (but not side/pedestrian).
+            const mainDoor = doors.find(door => /portail|main|gate|principal|entry|front/i.test(door.name) && !/portillon|side|pedestrian|pieton|wicket|back/i.test(door.name));
+            // Strategy 3: Use the first door as main door.
+            this.mainDoorLocationId = mainDoor?.unique_id ?? doors[0].unique_id;
+        }
+        // Find the side door (if enabled).
+        if (this.hints.hasSideDoor) {
+            // Strategy 1: Check extensions for oper2 port setting.
+            const sideDoorFromExt = this.uda.extensions?.find(ext => (ext.extension_name === "port_setting") && (ext.target_name === "oper2"))?.target_value;
+            if (sideDoorFromExt) {
+                this.sideDoorLocationId = sideDoorFromExt;
+            }
+            else {
+                // Strategy 2: Look for a door named like "side", "portillon", "pedestrian".
+                const sideDoor = doors.find(door => (door.unique_id !== this.mainDoorLocationId) && /portillon|side|pedestrian|pieton|wicket|back|secondary/i.test(door.name));
+                if (sideDoor) {
+                    this.sideDoorLocationId = sideDoor.unique_id;
+                }
+                else if (doors.length === 2) {
+                    // Strategy 3: If we have exactly 2 doors, the other one is the side door.
+                    const otherDoor = doors.find(door => door.unique_id !== this.mainDoorLocationId);
+                    this.sideDoorLocationId = otherDoor?.unique_id;
+                }
+            }
+        }
+        // Initialize door states from the already-loaded doors data.
+        this.initializeDoorsFromBootstrap(doors);
+    }
+    // Initialize door states from the doors data loaded during API bootstrap. This avoids making additional API calls which may fail.
+    initializeDoorsFromBootstrap(doors) {
+        // Find and initialize main door state.
+        if (this.mainDoorLocationId) {
+            const mainDoor = doors.find(d => d.unique_id === this.mainDoorLocationId);
+            if (mainDoor) {
+                const dpsStatus = mainDoor.door_position_status ?? "close";
+                const lockStatus = mainDoor.door_lock_relay_status ?? "lock";
+                // Set DPS state.
+                const newDpsState = dpsStatus === "open" ? this.hap.Characteristic.ContactSensorState.CONTACT_NOT_DETECTED :
+                    this.hap.Characteristic.ContactSensorState.CONTACT_DETECTED;
+                this.hkDpsState = newDpsState;
+                // Set lock state.
+                const newLockState = lockStatus === "unlock" ? this.hap.Characteristic.LockCurrentState.UNSECURED : this.hap.Characteristic.LockCurrentState.SECURED;
+                this._hkLockState = newLockState;
+                // Update the door service.
+                if (this.doorServiceType === "GarageDoorOpener") {
+                    this.updateDoorServiceState(false);
+                }
+            }
+        }
+        // Find and initialize side door state.
+        if (this.sideDoorLocationId && this.hints.hasSideDoor) {
+            const sideDoor = doors.find(d => d.unique_id === this.sideDoorLocationId);
+            if (sideDoor) {
+                const dpsStatus = sideDoor.door_position_status ?? "close";
+                const lockStatus = sideDoor.door_lock_relay_status ?? "lock";
+                // Set DPS state.
+                const newDpsState = dpsStatus === "open" ? this.hap.Characteristic.ContactSensorState.CONTACT_NOT_DETECTED :
+                    this.hap.Characteristic.ContactSensorState.CONTACT_DETECTED;
+                this._hkSideDoorDpsState = newDpsState;
+                // Set lock state.
+                const newLockState = lockStatus === "unlock" ? this.hap.Characteristic.LockCurrentState.UNSECURED : this.hap.Characteristic.LockCurrentState.SECURED;
+                this._hkSideDoorLockState = newLockState;
+            }
+        }
+    }
     // Initialize and configure the light accessory for HomeKit.
     configureDevice() {
         this._hkLockState = this.hubLockState;
+        this._hkSideDoorDpsState = this.hubSideDoorDpsState;
+        this._hkSideDoorLockState = this.hubSideDoorLockState;
         // Clean out the context object in case it's been polluted somehow.
         this.accessory.context = {};
         this.accessory.context.mac = this.uda.mac;
@@ -99,24 +224,49 @@ export class AccessHub extends AccessDevice {
         else {
             this.log.info("The door lock relay will remain unlocked %s after unlocking in HomeKit.", this.lockDelayInterval === 0 ? "indefinitely" : "for " + this.lockDelayInterval.toString() + " minutes");
         }
+        if (this.hints.hasSideDoor) {
+            if (this.lockDelayInterval === undefined) {
+                this.log.info("The side door lock relay will lock five seconds after unlocking in HomeKit.");
+            }
+            else {
+                this.log.info("The side door lock relay will remain unlocked %s after unlocking in HomeKit.", this.lockDelayInterval === 0 ? "indefinitely" : "for " + this.lockDelayInterval.toString() + " minutes");
+            }
+        }
         // Configure accessory information.
         this.configureInfo();
         // Configure access method switches, if we're a reader device.
         this.configureAccessMethodSwitches();
+        // Configure the sensors connected to terminal inputs. This must be done before configuring the lock so that the DPS contact sensor exists when configuring a
+        // GarageDoorOpener service, which derives its state from the DPS sensor.
+        this.configureTerminalInputs();
+        this.configureSideDoorTerminalInputs();
         // Configure the lock, if we're a hub device.
         this.configureLock();
         this.configureLockTrigger();
+        // Configure the side door lock, if we're a UA Gate device.
+        this.configureSideDoorLock();
+        this.configureSideDoorLockTrigger();
         // Configure the doorbell, if we have one.
         this.configureDoorbell();
         this.configureDoorbellTrigger();
-        // Configure the sensors connected to terminal inputs.
-        this.configureTerminalInputs();
         // Configure MQTT services.
         this.configureMqtt();
         // Listen for events.
         this.controller.events.on(this.uda.unique_id, this.listeners[this.uda.unique_id] = this.eventHandler.bind(this));
         this.controller.events.on("access.remote_view", this.listeners["access.remote_view"] = this.eventHandler.bind(this));
         this.controller.events.on("access.remote_view.change", this.listeners["access.remote_view.change"] = this.eventHandler.bind(this));
+        // For UA Gate hubs, we discover door IDs and subscribe to their events. This is needed because remote_unlock events use the door's location_id as the
+        // event_object_id, not the hub's device_id.
+        if (this.uda.device_type === "UGT") {
+            this.discoverDoorIds();
+            // Subscribe to events for both doors.
+            if (this.mainDoorLocationId) {
+                this.controller.events.on(this.mainDoorLocationId, this.listeners[this.mainDoorLocationId] = this.eventHandler.bind(this));
+            }
+            if (this.sideDoorLocationId) {
+                this.controller.events.on(this.sideDoorLocationId, this.listeners[this.sideDoorLocationId] = this.eventHandler.bind(this));
+            }
+        }
         return true;
     }
     // Configure the access method switches for HomeKit.
@@ -212,28 +362,71 @@ export class AccessHub extends AccessDevice {
         }
         return true;
     }
-    // Configure the lock for HomeKit.
+    // Configure contact sensors for the side door terminal inputs on UA Gate hubs. The side door has its own dedicated DPS input separate from the main gate's DPS.
+    configureSideDoorTerminalInputs() {
+        // We only configure side door terminal inputs for UA Gate hubs that have the side door enabled.
+        if (!this.hints.hasSideDoor) {
+            return false;
+        }
+        // Validate whether we should have this service enabled. We check the hasWiringSideDoorDps hint which already incorporates the feature option check.
+        if (!validService(this.accessory, this.hap.Service.ContactSensor, (hasService) => {
+            if (!this.hints.hasWiringSideDoorDps && hasService) {
+                this.log.info("Disabling the side door position sensor.");
+            }
+            return this.hints.hasWiringSideDoorDps;
+        }, AccessReservedNames.CONTACT_DPS_SIDE)) {
+            return false;
+        }
+        // Acquire the service.
+        const service = acquireService(this.accessory, this.hap.Service.ContactSensor, this.accessoryName + " Side Door Position Sensor", AccessReservedNames.CONTACT_DPS_SIDE, () => this.log.info("Enabling the side door position sensor."));
+        if (!service) {
+            this.log.error("Unable to add the side door position sensor.");
+            return false;
+        }
+        // Initialize the sensor state from the current side door DPS state.
+        service.updateCharacteristic(this.hap.Characteristic.ContactSensorState, this._hkSideDoorDpsState);
+        service.updateCharacteristic(this.hap.Characteristic.StatusActive, !!this.uda.is_online);
+        // If the hub has tamper indicator capabilities, 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);
+            }
+        }
+        return true;
+    }
+    // Configure the door for HomeKit. Supports Lock and GarageDoorOpener service types.
     configureLock() {
+        // First, remove any previous service types that are no longer selected.
+        const serviceTypes = [this.hap.Service.LockMechanism, this.hap.Service.GarageDoorOpener];
+        const selectedService = this.doorServiceType === "GarageDoorOpener" ? this.hap.Service.GarageDoorOpener : this.hap.Service.LockMechanism;
+        for (const serviceType of serviceTypes) {
+            if (serviceType !== selectedService) {
+                const oldService = this.accessory.getService(serviceType);
+                if (oldService) {
+                    this.accessory.removeService(oldService);
+                }
+            }
+        }
         // Validate whether we should have this service enabled.
-        if (!validService(this.accessory, this.hap.Service.LockMechanism, this.hasCapability("is_hub"))) {
+        if (!validService(this.accessory, selectedService, this.hasCapability("is_hub"))) {
             return false;
         }
         // Acquire the service.
-        const service = acquireService(this.accessory, this.hap.Service.LockMechanism, this.accessoryName);
+        const service = acquireService(this.accessory, selectedService, this.accessoryName, undefined, () => this.log.info("Configuring door as %s service.", this.doorServiceType));
         if (!service) {
-            this.log.error("Unable to add the lock.");
+            this.log.error("Unable to add the door.");
             return false;
         }
-        // Return the lock state.
-        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);
-            }
-            service.updateCharacteristic(this.hap.Characteristic.LockCurrentState, this.hkLockState);
-        });
-        // Initialize the lock.
+        // Configure based on service type.
+        if (this.doorServiceType === "GarageDoorOpener") {
+            this.configureGarageDoorService(service, false);
+        }
+        else {
+            this.configureLockService(service, false);
+        }
+        // Initialize the state.
         this._hkLockState = -1;
         service.displayName = this.accessoryName;
         service.updateCharacteristic(this.hap.Characteristic.Name, this.accessoryName);
@@ -241,6 +434,100 @@ export class AccessHub extends AccessDevice {
         service.setPrimaryService(true);
         return true;
     }
+    // Configure a LockMechanism service.
+    configureLockService(service, isSideDoor) {
+        if (!service) {
+            return;
+        }
+        const lockStateGetter = isSideDoor ? () => this.hkSideDoorLockState : () => this.hkLockState;
+        const lockCommand = isSideDoor ? async (lock) => this.hubSideDoorLockCommand(lock) :
+            async (lock) => this.hubLockCommand(lock);
+        service.getCharacteristic(this.hap.Characteristic.LockCurrentState).onGet(lockStateGetter);
+        service.getCharacteristic(this.hap.Characteristic.LockTargetState).onGet(lockStateGetter);
+        service.getCharacteristic(this.hap.Characteristic.LockTargetState).onSet(async (value) => {
+            // Check if this is just syncing state from an event (current state already matches target).
+            const currentState = lockStateGetter();
+            const targetLocked = value === this.hap.Characteristic.LockTargetState.SECURED;
+            const currentlyLocked = currentState === this.hap.Characteristic.LockCurrentState.SECURED;
+            // If state already matches, this is just a sync from an event - don't send command.
+            if (targetLocked === currentlyLocked) {
+                return;
+            }
+            if (!(await lockCommand(targetLocked))) {
+                setTimeout(() => service.updateCharacteristic(this.hap.Characteristic.LockTargetState, currentlyLocked ? this.hap.Characteristic.LockTargetState.SECURED : this.hap.Characteristic.LockTargetState.UNSECURED), 50);
+            }
+            service.updateCharacteristic(this.hap.Characteristic.LockCurrentState, lockStateGetter());
+        });
+    }
+    // Configure a GarageDoorOpener service.
+    configureGarageDoorService(service, isSideDoor) {
+        if (!service) {
+            return;
+        }
+        // For UA Gate, we use unlock/trigger command for both open and close operations. The gate motor will move in the appropriate direction based on its current state.
+        // For non-UA Gate hubs, we use lock/unlock commands directly (locked = closed, unlocked = open).
+        const isUaGate = this.uda.device_type === "UGT";
+        // Determine the current door state. For UA Gate, we use DPS (Door Position Sensor) state since it's a motorized gate with physical positions. For non-UA Gate hubs,
+        // we derive state from the lock relay (locked = closed, unlocked = open) since GarageDoorOpener is just a visual convenience for the same underlying lock behavior.
+        const getDoorState = () => {
+            if (isUaGate) {
+                const dpsState = isSideDoor ? this._hkSideDoorDpsState : this.hkDpsState;
+                return dpsState === this.hap.Characteristic.ContactSensorState.CONTACT_DETECTED ? this.hap.Characteristic.CurrentDoorState.CLOSED :
+                    this.hap.Characteristic.CurrentDoorState.OPEN;
+            }
+            // Non-UA Gate hubs: derive from lock relay state.
+            const lockState = isSideDoor ? this.hkSideDoorLockState : this.hkLockState;
+            return this.isLocked(lockState) ? this.hap.Characteristic.CurrentDoorState.CLOSED : this.hap.Characteristic.CurrentDoorState.OPEN;
+        };
+        service.getCharacteristic(this.hap.Characteristic.CurrentDoorState).onGet(getDoorState);
+        service.getCharacteristic(this.hap.Characteristic.TargetDoorState).onSet(async (value) => {
+            const shouldClose = value === this.hap.Characteristic.TargetDoorState.CLOSED;
+            // UA Gate uses a single trigger command that toggles the motorized gate. Non-UA Gate hubs use explicit lock/unlock commands.
+            if (isUaGate) {
+                // Set a transition cooldown to prevent WebSocket events from immediately reverting the door state. This gives the gate time to physically move before we accept
+                // DPS updates.
+                if (isSideDoor) {
+                    this.sideDoorGateTransitionUntil = Date.now() + GATE_TRANSITION_COOLDOWN_MS;
+                }
+                else {
+                    this.gateTransitionUntil = Date.now() + GATE_TRANSITION_COOLDOWN_MS;
+                }
+                // Immediately show transitional state (Opening/Closing) while the door moves.
+                service.updateCharacteristic(this.hap.Characteristic.CurrentDoorState, shouldClose ? this.hap.Characteristic.CurrentDoorState.CLOSING :
+                    this.hap.Characteristic.CurrentDoorState.OPENING);
+                // Trigger the gate - for motorized gates, the same trigger command handles both open and close.
+                const triggerGate = isSideDoor ? async () => this.hubSideDoorLockCommand(false) : async () => this.hubLockCommand(false);
+                if (!(await triggerGate())) {
+                    // Clear the transition cooldown on failure.
+                    if (isSideDoor) {
+                        this.sideDoorGateTransitionUntil = 0;
+                    }
+                    else {
+                        this.gateTransitionUntil = 0;
+                    }
+                    // Revert target state on failure.
+                    setTimeout(() => {
+                        service.updateCharacteristic(this.hap.Characteristic.TargetDoorState, shouldClose ? this.hap.Characteristic.TargetDoorState.OPEN : this.hap.Characteristic.TargetDoorState.CLOSED);
+                        service.updateCharacteristic(this.hap.Characteristic.CurrentDoorState, getDoorState());
+                    }, 50);
+                }
+                // The DPS sensor event will update the CurrentDoorState when the gate finishes moving.
+                return;
+            }
+            // Non-UA Gate hubs: use lock/unlock commands directly (close = lock, open = unlock). The lock state change will drive the door state update via hkLockState setter.
+            const lockCommand = isSideDoor ? async (lock) => this.hubSideDoorLockCommand(lock) :
+                async (lock) => this.hubLockCommand(lock);
+            if (!(await lockCommand(shouldClose))) {
+                // Revert target state on failure.
+                setTimeout(() => {
+                    service.updateCharacteristic(this.hap.Characteristic.TargetDoorState, shouldClose ? this.hap.Characteristic.TargetDoorState.OPEN : this.hap.Characteristic.TargetDoorState.CLOSED);
+                    service.updateCharacteristic(this.hap.Characteristic.CurrentDoorState, getDoorState());
+                }, 50);
+            }
+        });
+        // ObstructionDetected is required - we always report no obstruction.
+        service.getCharacteristic(this.hap.Characteristic.ObstructionDetected).onGet(() => false);
+    }
     // Configure a switch to manually trigger a doorbell ring event for HomeKit.
     configureDoorbellTrigger() {
         // Validate whether we should have this service enabled.
@@ -291,6 +578,54 @@ export class AccessHub extends AccessDevice {
         service.updateCharacteristic(this.hap.Characteristic.On, false);
         return true;
     }
+    // Configure the side door for HomeKit (UA Gate only) - always uses Lock service.
+    configureSideDoorLock() {
+        // Validate whether we should have this service enabled.
+        if (!validService(this.accessory, this.hap.Service.LockMechanism, this.hints.hasSideDoor, AccessReservedNames.LOCK_DOOR_SIDE)) {
+            return false;
+        }
+        // Acquire the service.
+        const service = acquireService(this.accessory, this.hap.Service.LockMechanism, this.accessoryName + " Side Door", AccessReservedNames.LOCK_DOOR_SIDE, () => this.log.info("Configuring side door lock."));
+        if (!service) {
+            this.log.error("Unable to add the side door.");
+            return false;
+        }
+        // Configure the lock service.
+        this.configureLockService(service, true);
+        // Initialize the lock.
+        this._hkSideDoorLockState = -1;
+        service.displayName = this.accessoryName + " Side Door";
+        service.updateCharacteristic(this.hap.Characteristic.Name, this.accessoryName + " Side Door");
+        this.hkSideDoorLockState = this.hubSideDoorLockState;
+        return true;
+    }
+    // Configure a switch to automate side door lock and unlock events in HomeKit beyond what HomeKit might allow for a lock service that gets treated as a secure service.
+    configureSideDoorLockTrigger() {
+        // Validate whether we should have this service enabled.
+        if (!validService(this.accessory, this.hap.Service.Switch, this.hints.hasSideDoor && this.hasFeature("Hub.SideDoor.Lock.Trigger"), AccessReservedNames.SWITCH_LOCK_DOOR_SIDE_TRIGGER)) {
+            return false;
+        }
+        // Acquire the service.
+        const service = acquireService(this.accessory, this.hap.Service.Switch, this.accessoryName + " Side Door Lock Trigger", AccessReservedNames.SWITCH_LOCK_DOOR_SIDE_TRIGGER, () => this.log.info("Enabling the side door lock automation trigger."));
+        if (!service) {
+            this.log.error("Unable to add the side door lock automation trigger.");
+            return false;
+        }
+        // Trigger the lock state.
+        service.getCharacteristic(this.hap.Characteristic.On).onGet(() => this.hkSideDoorLockState !== 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) => {
+            // If we are on, we are in an unlocked state. If we are off, we are in a locked state.
+            if (!(await this.hubSideDoorLockCommand(!value))) {
+                // Revert our state.
+                setTimeout(() => service.updateCharacteristic(this.hap.Characteristic.On, !value), 50);
+            }
+        });
+        // Initialize the switch.
+        service.updateCharacteristic(this.hap.Characteristic.ConfiguredName, this.accessoryName + " Side Door Lock Trigger");
+        service.updateCharacteristic(this.hap.Characteristic.On, false);
+        return true;
+    }
     // Configure MQTT capabilities of this light.
     configureMqtt() {
         const lockService = this.accessory.getService(this.hap.Service.LockMechanism);
@@ -340,6 +675,46 @@ export class AccessHub extends AccessDevice {
                     break;
             }
         });
+        // MQTT side door lock status (UA Gate only).
+        if (this.hints.hasSideDoor) {
+            this.controller.mqtt?.subscribeGet(this.id, "sidedoor/lock", "Side Door Lock", () => {
+                switch (this.hkSideDoorLockState) {
+                    case this.hap.Characteristic.LockCurrentState.SECURED:
+                        return "true";
+                    case this.hap.Characteristic.LockCurrentState.UNSECURED:
+                        return "false";
+                    default:
+                        return "unknown";
+                }
+            });
+            this.controller.mqtt?.subscribeSet(this.id, "sidedoor/lock", "Side Door Lock", (value) => {
+                switch (value) {
+                    case "true":
+                        void this.hubSideDoorLockCommand(true);
+                        break;
+                    case "false":
+                        void this.hubSideDoorLockCommand(false);
+                        break;
+                    default:
+                        this.log.error("MQTT: Unknown side door lock set message received: %s.", value);
+                        break;
+                }
+            });
+            // MQTT side door DPS status (UA Gate only).
+            this.controller.mqtt?.subscribeGet(this.id, "sidedoor/dps", "Side door position sensor", () => {
+                if (!this.isSideDoorDpsWired) {
+                    return "unknown";
+                }
+                switch (this._hkSideDoorDpsState) {
+                    case this.hap.Characteristic.ContactSensorState.CONTACT_DETECTED:
+                        return "false";
+                    case this.hap.Characteristic.ContactSensorState.CONTACT_NOT_DETECTED:
+                        return "true";
+                    default:
+                        return "unknown";
+                }
+            });
+        }
         return true;
     }
     // Check and validate Ultra inputs with what the user has configured in HomeKit.
@@ -348,7 +723,7 @@ export class AccessHub extends AccessDevice {
             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);
+            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;
@@ -359,26 +734,91 @@ export class AccessHub extends AccessDevice {
             }
         }
     }
-    // Utility function to execute lock and unlock actions on a hub.
-    async hubLockCommand(isLocking) {
+    // Unified utility function to execute lock and unlock actions on a hub door.
+    async hubDoorLockCommand(isLocking, isSideDoor = false) {
         const action = isLocking ? "lock" : "unlock";
-        // Only allow relocking if we are able to do so.
-        if ((this.lockDelayInterval === undefined) && isLocking) {
-            this.log.error("Unable to manually relock when the lock relay is configured to the default settings.");
+        const doorName = isSideDoor ? "side door" : (this.uda.device_type === "UGT" ? "gate" : "door");
+        const doorId = isSideDoor ? this.sideDoorLocationId : this.mainDoorLocationId;
+        // Only allow relocking if we are able to do so. UA Gate is exempt since it's a motorized gate that needs to close. For non-UA Gate hubs, the same restriction
+        // applies to both Lock and GarageDoorOpener service types since GarageDoorOpener is just a visual convenience for the same underlying lock behavior.
+        if ((this.lockDelayInterval === undefined) && isLocking && (this.uda.device_type !== "UGT")) {
+            this.log.error("Unable to manually relock the %s when the lock relay is configured to the default settings.", doorName);
             return false;
         }
         // If we're not online, we're done.
         if (!this.isOnline) {
-            this.log.error("Unable to %s. Device is offline.", action);
+            this.log.error("Unable to %s the %s. Device is offline.", action, doorName);
             return false;
         }
+        // For UA Gate hubs, use the location-based unlock API since the device API is not supported.
+        if (this.uda.device_type === "UGT") {
+            if (!doorId) {
+                this.log.error("Unable to %s the %s. Door not found.", action, isSideDoor ? "side door" : "gate");
+                return false;
+            }
+            // Execute the action using the location endpoint.
+            const endpoint = this.controller.udaApi.getApiEndpoint("location") + "/" + doorId + "/unlock";
+            const response = await this.controller.udaApi.retrieve(endpoint, {
+                body: JSON.stringify({}),
+                method: "PUT"
+            });
+            if (!this.controller.udaApi.responseOk(response?.statusCode)) {
+                this.log.error("Unable to %s the %s.", action, doorName);
+                return false;
+            }
+            // When unlocking from HomeKit, the controller doesn't send the events to the events API. Manually update the state and schedule the auto-lock.
+            if (!isLocking) {
+                if (isSideDoor) {
+                    this.hkSideDoorLockState = this.hap.Characteristic.LockCurrentState.UNSECURED;
+                    if (this.hints.logLock) {
+                        this.log.info("Side door unlocked.");
+                    }
+                    setTimeout(() => {
+                        this.hkSideDoorLockState = this.hap.Characteristic.LockCurrentState.SECURED;
+                        if (this.hints.logLock) {
+                            this.log.info("Side door locked.");
+                        }
+                    }, AUTO_LOCK_DELAY_MS);
+                }
+                else {
+                    this.hkLockState = this.hap.Characteristic.LockCurrentState.UNSECURED;
+                    setTimeout(() => this.hkLockState = this.hap.Characteristic.LockCurrentState.SECURED, AUTO_LOCK_DELAY_MS);
+                }
+            }
+            return true;
+        }
+        // For hub types other than UA Gate, we use the standard device unlock API. GarageDoorOpener uses the same lock delay interval as Lock service since it's just a
+        // visual convenience for the same underlying lock behavior.
+        const delayInterval = this.lockDelayInterval;
         // Execute the action.
-        if (!(await this.controller.udaApi.unlock(this.uda, (this.lockDelayInterval === undefined) ? undefined : (isLocking ? 0 : Infinity)))) {
+        if (!(await this.controller.udaApi.unlock(this.uda, (delayInterval === undefined) ? undefined : (isLocking ? 0 : Infinity)))) {
             this.log.error("Unable to %s.", action);
             return false;
         }
         return true;
     }
+    // Wrapper for door lock command.
+    async hubLockCommand(isLocking) {
+        return this.hubDoorLockCommand(isLocking);
+    }
+    // Wrapper for side door lock command (for backwards compatibility).
+    async hubSideDoorLockCommand(isLocking) {
+        return this.hubDoorLockCommand(isLocking, true);
+    }
+    // Return the current HomeKit DPS state that we are tracking for this hub. We read from the contact sensor service if it exists, otherwise we fall back to the
+    // backing variable. This allows GarageDoorOpener to function correctly even when the DPS contact sensor is disabled.
+    get hkDpsState() {
+        const service = this.accessory.getServiceById(this.hap.Service.ContactSensor, AccessReservedNames.CONTACT_DPS);
+        if (service) {
+            return service.getCharacteristic(this.hap.Characteristic.ContactSensorState).value ?? this._hkDpsState;
+        }
+        return this._hkDpsState;
+    }
+    // Set the current HomeKit DPS state for this hub. We always update the backing variable and also update the contact sensor service if it exists.
+    set hkDpsState(value) {
+        this._hkDpsState = value;
+        this.setContactSensorState(AccessReservedNames.CONTACT_DPS, value);
+    }
     // Return the current HomeKit lock state that we are tracking for this hub.
     get hkLockState() {
         return this._hkLockState;
@@ -391,16 +831,79 @@ export class AccessHub extends AccessDevice {
         }
         // Update the lock state.
         this._hkLockState = value;
-        // Retrieve the lock service.
-        const lockService = this.accessory.getService(this.hap.Service.LockMechanism);
-        if (!lockService) {
+        // For Lock service type, update the service. For GarageDoorOpener on non-UA Gate hubs, also update the service since door state is derived from lock state. For UA
+        // Gate with GarageDoorOpener, DPS events handle updates since it's a motorized gate with physical positions.
+        if ((this.doorServiceType === "Lock") || (this.uda.device_type !== "UGT")) {
+            this.updateDoorServiceState(false);
+        }
+        else {
+            // UA Gate with GarageDoorOpener: only update the lock trigger switch if enabled.
+            this.accessory.getServiceById(this.hap.Service.Switch, AccessReservedNames.SWITCH_LOCK_TRIGGER)?.updateCharacteristic(this.hap.Characteristic.On, value !== this.hap.Characteristic.LockCurrentState.SECURED);
+        }
+    }
+    // Update door service state based on configured service type.
+    updateDoorServiceState(isSideDoor) {
+        const serviceType = isSideDoor ? "Lock" : this.doorServiceType;
+        const lockState = isSideDoor ? this.hkSideDoorLockState : this.hkLockState;
+        const triggerSubtype = isSideDoor ? AccessReservedNames.SWITCH_LOCK_DOOR_SIDE_TRIGGER : AccessReservedNames.SWITCH_LOCK_TRIGGER;
+        // Check if we're in a transition cooldown period - skip updates to preserve the Opening/Closing state.
+        const transitionUntil = isSideDoor ? this.sideDoorGateTransitionUntil : this.gateTransitionUntil;
+        if (serviceType === "GarageDoorOpener") {
+            // GarageDoorOpener is only used for the primary door, which has no subtype.
+            const service = this.accessory.getService(this.hap.Service.GarageDoorOpener);
+            if (service) {
+                // UA Gate uses DPS state since it's a motorized gate with physical positions. Non-UA Gate hubs derive state from lock relay (locked = closed, unlocked = open)
+                // since GarageDoorOpener is just a visual convenience for the same underlying lock behavior.
+                if (this.uda.device_type === "UGT") {
+                    const dpsState = isSideDoor ? this._hkSideDoorDpsState : this.hkDpsState;
+                    const doorState = dpsState === this.hap.Characteristic.ContactSensorState.CONTACT_DETECTED ? this.hap.Characteristic.CurrentDoorState.CLOSED :
+                        this.hap.Characteristic.CurrentDoorState.OPEN;
+                    const targetState = dpsState === this.hap.Characteristic.ContactSensorState.CONTACT_DETECTED ?
+                        this.hap.Characteristic.TargetDoorState.CLOSED : this.hap.Characteristic.TargetDoorState.OPEN;
+                    // If in transition cooldown, ignore all DPS updates to let the gate stabilize. The gate sensor often bounces between open/closed during movement. We'll accept
+                    // the final state once the cooldown expires.
+                    if (Date.now() < transitionUntil) {
+                        return;
+                    }
+                    service.updateCharacteristic(this.hap.Characteristic.TargetDoorState, targetState);
+                    service.updateCharacteristic(this.hap.Characteristic.CurrentDoorState, doorState);
+                }
+                else {
+                    // Non-UA Gate hubs: derive from lock relay state.
+                    const doorState = this.isLocked(lockState) ? this.hap.Characteristic.CurrentDoorState.CLOSED : this.hap.Characteristic.CurrentDoorState.OPEN;
+                    const targetState = this.isLocked(lockState) ? this.hap.Characteristic.TargetDoorState.CLOSED : this.hap.Characteristic.TargetDoorState.OPEN;
+                    service.updateCharacteristic(this.hap.Characteristic.TargetDoorState, targetState);
+                    service.updateCharacteristic(this.hap.Characteristic.CurrentDoorState, doorState);
+                }
+            }
+        }
+        else {
+            // The primary door has no subtype. The side door (UA Gate only) uses a subtype to distinguish it.
+            const service = isSideDoor ? this.accessory.getServiceById(this.hap.Service.LockMechanism, AccessReservedNames.LOCK_DOOR_SIDE) :
+                this.accessory.getService(this.hap.Service.LockMechanism);
+            if (service) {
+                service.updateCharacteristic(this.hap.Characteristic.LockTargetState, lockState === this.hap.Characteristic.LockCurrentState.UNSECURED ?
+                    this.hap.Characteristic.LockTargetState.UNSECURED : this.hap.Characteristic.LockTargetState.SECURED);
+                service.updateCharacteristic(this.hap.Characteristic.LockCurrentState, lockState);
+            }
+        }
+        // Update the lock trigger switch if enabled.
+        this.accessory.getServiceById(this.hap.Service.Switch, triggerSubtype)?.updateCharacteristic(this.hap.Characteristic.On, lockState !== this.hap.Characteristic.LockCurrentState.SECURED);
+    }
+    // Return the current HomeKit side door lock state that we are tracking for this hub.
+    get hkSideDoorLockState() {
+        return this._hkSideDoorLockState;
+    }
+    // Set the current HomeKit side door lock state for this hub.
+    set hkSideDoorLockState(value) {
+        // If nothing is changed, we're done.
+        if (this.hkSideDoorLockState === value) {
             return;
         }
-        // Update the state in HomeKit.
-        lockService.updateCharacteristic(this.hap.Characteristic.LockTargetState, this.hkLockState === this.hap.Characteristic.LockCurrentState.UNSECURED ?
-            this.hap.Characteristic.LockTargetState.UNSECURED : this.hap.Characteristic.LockTargetState.SECURED);
-        lockService.updateCharacteristic(this.hap.Characteristic.LockCurrentState, this.hkLockState);
-        this.accessory.getServiceById(this.hap.Service.Switch, AccessReservedNames.SWITCH_LOCK_TRIGGER)?.updateCharacteristic(this.hap.Characteristic.On, this.hkLockState !== this.hap.Characteristic.LockCurrentState.SECURED);
+        // Update the lock state.
+        this._hkSideDoorLockState = value;
+        // Update the lock service state.
+        this.updateDoorServiceState(true);
     }
     // Return the current state of the DPS on the hub.
     get hubDpsState() {
@@ -425,6 +928,16 @@ export class AccessHub extends AccessDevice {
         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 side door DPS on the UA Gate hub.
+    get hubSideDoorDpsState() {
+        // If we don't have the wiring connected for the side door DPS, we report our default closed state.
+        if (!this.isSideDoorDpsWired) {
+            return this.hap.Characteristic.ContactSensorState.CONTACT_DETECTED;
+        }
+        // Return our side door DPS state. If it's anything other than on, we assume it's open.
+        return (this.uda.configs?.find(entry => entry.key === "input_door_dps")?.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.
     get hubLockState() {
         let relayType;
@@ -443,6 +956,15 @@ export class AccessHub extends AccessDevice {
         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 side door relay lock on the UA Gate hub.
+    get hubSideDoorLockState() {
+        // Side door lock is only available on UA Gate.
+        if (this.uda.device_type !== "UGT") {
+            return this.hap.Characteristic.LockCurrentState.SECURED;
+        }
+        const lockRelay = this.uda.configs?.find(entry => entry.key === "output_oper2_relay");
+        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.
@@ -501,11 +1023,20 @@ export class AccessHub extends AccessDevice {
         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 wiring state of the side door DPS on UA Gate hubs. The side door DPS uses different wiring keys than the main gate DPS.
+    get isSideDoorDpsWired() {
+        // Side door DPS is only available on UA Gate.
+        if (this.uda.device_type !== "UGT") {
+            return false;
+        }
+        // Check if the side door DPS is wired (wiring_state_door-dps-neg and wiring_state_door-dps-pos).
+        return ["wiring_state_door-dps-neg", "wiring_state_door-dps-pos"].every(wire => this.uda.configs?.some(e => (e.key === wire) && (e.value === "on")));
+    }
     // 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;
+            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];
@@ -528,109 +1059,284 @@ export class AccessHub extends AccessDevice {
     hasCapability(capability) {
         return Array.isArray(capability) ? capability.some(c => this.uda.capabilities.includes(c)) : this.uda.capabilities.includes(capability);
     }
-    // Handle hub-related events.
-    eventHandler(packet) {
+    // Update door state from location data (lock and DPS).
+    updateDoorFromLocationState(doorState, isSideDoor) {
+        const newLockState = this.toLockState(doorState.lock);
+        const newDpsState = this.toDpsState(doorState.dps);
+        const doorName = isSideDoor ? "Side door" : "";
+        // Update lock state.
+        const currentLockState = isSideDoor ? this.hkSideDoorLockState : this.hkLockState;
+        if (newLockState !== currentLockState) {
+            if (isSideDoor) {
+                this.hkSideDoorLockState = newLockState;
+                this.controller.mqtt?.publish(this.id, "sidedoor/lock", this.isLocked(newLockState) ? "true" : "false");
+                if (this.hints.logLock) {
+                    this.log.info("%s %s.", doorName, this.isLocked(newLockState) ? "locked" : "unlocked");
+                }
+            }
+            else {
+                this.hkLockState = newLockState;
+                this.controller.mqtt?.publish(this.id, "lock", this.isLocked(newLockState) ? "true" : "false");
+                if (this.hints.logLock) {
+                    this.log.info(this.isLocked(newLockState) ? "Locked." : "Unlocked.");
+                }
+            }
+        }
+        // Update DPS state.
+        const currentDpsState = isSideDoor ? this._hkSideDoorDpsState : this.hkDpsState;
+        if (newDpsState !== currentDpsState) {
+            const contactDetected = this.isClosed(newDpsState);
+            if (isSideDoor) {
+                this._hkSideDoorDpsState = newDpsState;
+                this.setContactSensorState(AccessReservedNames.CONTACT_DPS_SIDE, newDpsState);
+                this.controller.mqtt?.publish(this.id, "sidedoor/dps", contactDetected ? "false" : "true");
+                if (this.hints.logDps) {
+                    this.log.info("Side door position sensor %s.", contactDetected ? "closed" : "open");
+                }
+            }
+            else {
+                this.hkDpsState = newDpsState;
+                this.controller.mqtt?.publish(this.id, "dps", contactDetected ? "false" : "true");
+                if ((this.doorServiceType === "GarageDoorOpener") || this.hints.logDps) {
+                    this.log.info("Door position sensor %s.", contactDetected ? "closed" : "open");
+                }
+                if (this.doorServiceType === "GarageDoorOpener") {
+                    this.updateDoorServiceState(false);
+                }
+            }
+        }
+    }
+    // Handle remote unlock events.
+    handleRemoteUnlock(packet) {
+        // For UA Gate hubs, determine which door was unlocked based on the event_object_id.
+        if (this.uda.device_type === "UGT") {
+            const eventDoorId = packet.event_object_id;
+            const isSideDoor = this.sideDoorLocationId && (eventDoorId === this.sideDoorLocationId);
+            const isMainDoor = this.mainDoorLocationId && (eventDoorId === this.mainDoorLocationId);
+            if (!isSideDoor && !isMainDoor) {
+                return;
+            }
+            const doorName = isSideDoor ? "Side door" : "Gate";
+            const mqttTopic = isSideDoor ? "sidedoor/lock" : "lock";
+            // Set unlocked state.
+            if (isSideDoor) {
+                this.hkSideDoorLockState = this.hap.Characteristic.LockCurrentState.UNSECURED;
+            }
+            else {
+                this.hkLockState = this.hap.Characteristic.LockCurrentState.UNSECURED;
+            }
+            this.controller.mqtt?.publish(this.id, mqttTopic, "false");
+            if (this.hints.logLock) {
+                this.log.info("%s unlocked.", doorName);
+            }
+            // Auto-lock after delay.
+            setTimeout(() => {
+                if (isSideDoor) {
+                    this.hkSideDoorLockState = this.hap.Characteristic.LockCurrentState.SECURED;
+                }
+                else {
+                    this.hkLockState = this.hap.Characteristic.LockCurrentState.SECURED;
+                }
+                this.controller.mqtt?.publish(this.id, mqttTopic, "true");
+                if (this.hints.logLock) {
+                    this.log.info("%s locked.", doorName);
+                }
+            }, AUTO_LOCK_DELAY_MS);
+        }
+        else {
+            // Non-UA Gate hubs: default behavior.
+            this.hkLockState = this.hap.Characteristic.LockCurrentState.UNSECURED;
+            this.controller.mqtt?.publish(this.id, "lock", "false");
+            if (this.hints.logLock) {
+                this.log.info("Unlocked.");
+            }
+        }
+    }
+    // Handle device update events (v1 API).
+    handleDeviceUpdate(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.
-                this.hkLockState = this.hap.Characteristic.LockCurrentState.UNSECURED;
-                // Publish to MQTT, if configured to do so.
-                this.controller.mqtt?.publish(this.id, "lock", "false");
+        // Process a lock update event if our state has changed. Skip for UA Gate hubs since we handle state manually because Access doesn't send those events out.
+        if ((this.uda.device_type !== "UGT") && (this.hubLockState !== this.hkLockState)) {
+            this.hkLockState = this.hubLockState;
+            this.controller.mqtt?.publish(this.id, "lock", this.isLocked(this.hkLockState) ? "true" : "false");
+            if (this.hints.logLock) {
+                this.log.info(this.isLocked(this.hkLockState) ? "Locked." : "Unlocked.");
+            }
+        }
+        // Process a side door lock update event if our state has changed (UA Gate only). We skip this for UGT since polling handles state updates.
+        if (this.hints.hasSideDoor && (this.uda.device_type !== "UGT")) {
+            const currentHkState = this.hkSideDoorLockState;
+            const newHubState = this.hubSideDoorLockState;
+            if (newHubState !== currentHkState) {
+                this.hkSideDoorLockState = newHubState;
+                this.controller.mqtt?.publish(this.id, "sidedoor/lock", this.isLocked(this.hkSideDoorLockState) ? "true" : "false");
                 if (this.hints.logLock) {
-                    this.log.info("Unlocked.");
+                    this.log.info("Side door %s.", this.isLocked(this.hkSideDoorLockState) ? "locked" : "unlocked");
                 }
-                break;
-            case "access.data.device.update":
-                // Process a lock update event if our state has changed.
-                if (this.hubLockState !== this.hkLockState) {
-                    this.hkLockState = this.hubLockState;
-                    this.controller.mqtt?.publish(this.id, "lock", this.hkLockState === this.hap.Characteristic.LockCurrentState.SECURED ? "true" : "false");
-                    if (this.hints.logLock) {
-                        this.log.info(this.hkLockState === this.hap.Characteristic.LockCurrentState.SECURED ? "Locked." : "Unlocked.");
-                    }
+            }
+        }
+        // Process a side door DPS update event if our state has changed (UA Gate only). We skip this for UGT since polling handles state updates.
+        if (this.hints.hasSideDoor && this.hints.hasWiringDps && (this.uda.device_type !== "UGT")) {
+            const newSideDoorDpsState = this.hubSideDoorDpsState;
+            if (newSideDoorDpsState !== this._hkSideDoorDpsState) {
+                this._hkSideDoorDpsState = newSideDoorDpsState;
+                const contactDetected = this.isClosed(this._hkSideDoorDpsState);
+                this.controller.mqtt?.publish(this.id, "sidedoor/dps", contactDetected ? "false" : "true");
+                if (this.hints.logDps) {
+                    this.log.info("Side door position sensor %s.", contactDetected ? "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 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.isClosed(this[hkKey]);
+                    this.controller.mqtt?.publish(this.id, topic, contactDetected ? "false" : "true");
+                    if (this.hints[logKey]) {
+                        this.log.info("%s %s.", 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);
+                // When DPS state changes on UA Gate, update the GarageDoorOpener service state. Non-UA Gate hubs with GarageDoorOpener derive state from lock relay changes
+                // instead, so DPS updates don't affect the door service.
+                if ((input === "Dps") && (this.doorServiceType === "GarageDoorOpener") && (this.uda.device_type === "UGT")) {
+                    this.updateDoorServiceState(false);
+                }
+            }
+        }
+        // Process any changes to terminal input configuration.
+        if (packet.data.extensions?.[0]?.target_config && (this.uda.display_model === "UA Ultra")) {
+            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);
+            }
+        }
+    }
+    // Handle device update v2 events.
+    handleDeviceUpdateV2(packet) {
+        const data = packet.data;
+        // Process access method updates.
+        if (data.access_method) {
+            const accessMethodData = data.access_method;
+            for (const [key, value] of Object.entries(accessMethodData)) {
+                const accessMethod = accessMethods.find(entry => entry.key === key);
+                if (accessMethod) {
+                    this.accessory.getServiceById(this.hap.Service.Switch, accessMethod.subtype)?.updateCharacteristic(this.hap.Characteristic.On, value === "yes");
+                }
+            }
+        }
+        // Process location_states for UA Gate hubs - this contains lock state per door.
+        if (data.location_states && (this.uda.device_type === "UGT")) {
+            const locationStates = data.location_states;
+            // Process main door state.
+            const mainDoorExtension = this.uda.extensions?.find(ext => ext.source_id === "port1");
+            const mainDoorId = mainDoorExtension?.target_value ?? this.mainDoorLocationId;
+            if (mainDoorId) {
+                const mainDoorState = locationStates.find(state => state.location_id === mainDoorId);
+                if (mainDoorState) {
+                    this.updateDoorFromLocationState(mainDoorState, false);
+                }
+            }
+            // Process side door state.
+            if (this.hints.hasSideDoor) {
+                const sideDoorExtension = this.uda.extensions?.find(ext => ext.source_id === "port2");
+                const sideDoorId = sideDoorExtension?.target_value ?? this.sideDoorLocationId;
+                if (sideDoorId) {
+                    const sideDoorState = locationStates.find(state => state.location_id === sideDoorId);
+                    if (sideDoorState) {
+                        this.updateDoorFromLocationState(sideDoorState, true);
                     }
                 }
+            }
+        }
+    }
+    // Handle location update events (v2 API).
+    handleLocationUpdate(packet) {
+        // Only process for UA Gate hubs.
+        if (this.uda.device_type !== "UGT") {
+            return;
+        }
+        const locationData = packet.data;
+        if (!locationData.state) {
+            return;
+        }
+        const locationId = locationData.id;
+        const isMainDoor = locationId === this.mainDoorLocationId;
+        const isSideDoor = locationId === this.sideDoorLocationId;
+        if (isMainDoor) {
+            this.updateDoorFromLocationState(locationData.state, false);
+        }
+        else if (isSideDoor && this.hints.hasSideDoor) {
+            this.updateDoorFromLocationState(locationData.state, true);
+        }
+    }
+    // Handle doorbell ring events.
+    handleDoorbellRing(packet) {
+        if ((packet.data.connected_uah_id !== this.uda.unique_id) || !this.hasCapability("door_bell")) {
+            return;
+        }
+        this.doorbellRingRequestId = packet.data.request_id;
+        // Trigger the doorbell event in HomeKit.
+        this.accessory.getService(this.hap.Service.Doorbell)?.getCharacteristic(this.hap.Characteristic.ProgrammableSwitchEvent)
+            ?.sendEventNotification(this.hap.Characteristic.ProgrammableSwitchEvent.SINGLE_PRESS);
+        // Update our doorbell trigger, if needed.
+        this.accessory.getServiceById(this.hap.Service.Switch, AccessReservedNames.SWITCH_DOORBELL_TRIGGER)?.updateCharacteristic(this.hap.Characteristic.On, true);
+        // Publish to MQTT.
+        this.controller.mqtt?.publish(this.id, "doorbell", "true");
+        if (this.hints.logDoorbell) {
+            this.log.info("Doorbell ring detected.");
+        }
+    }
+    // Handle doorbell cancel events.
+    handleDoorbellCancel(packet) {
+        if (this.doorbellRingRequestId !== packet.data.remote_call_request_id) {
+            return;
+        }
+        this.doorbellRingRequestId = null;
+        // Update our doorbell trigger, if needed.
+        this.accessory.getServiceById(this.hap.Service.Switch, AccessReservedNames.SWITCH_DOORBELL_TRIGGER)?.updateCharacteristic(this.hap.Characteristic.On, false);
+        // Publish to MQTT.
+        this.controller.mqtt?.publish(this.id, "doorbell", "false");
+        if (this.hints.logDoorbell) {
+            this.log.info("Doorbell ring cancelled.");
+        }
+    }
+    // Handle hub-related events.
+    eventHandler(packet) {
+        switch (packet.event) {
+            case "access.data.device.remote_unlock":
+                this.handleRemoteUnlock(packet);
+                break;
+            case "access.data.device.update":
+                this.handleDeviceUpdate(packet);
                 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");
-                    }
-                }
+                this.handleDeviceUpdateV2(packet);
+                break;
+            case "access.data.v2.location.update":
+                this.handleLocationUpdate(packet);
                 break;
             case "access.remote_view":
-                // Process an Access ring event if we're the intended target.
-                if ((packet.data.connected_uah_id !== this.uda.unique_id) || !this.hasCapability("door_bell")) {
-                    break;
-                }
-                this.doorbellRingRequestId = packet.data.request_id;
-                // Trigger the doorbell event in HomeKit.
-                this.accessory.getService(this.hap.Service.Doorbell)?.getCharacteristic(this.hap.Characteristic.ProgrammableSwitchEvent)
-                    ?.sendEventNotification(this.hap.Characteristic.ProgrammableSwitchEvent.SINGLE_PRESS);
-                // Update our doorbell trigger, if needed.
-                this.accessory.getServiceById(this.hap.Service.Switch, AccessReservedNames.SWITCH_DOORBELL_TRIGGER)?.updateCharacteristic(this.hap.Characteristic.On, true);
-                // Publish to MQTT, if configured to do so.
-                this.controller.mqtt?.publish(this.id, "doorbell", "true");
-                if (this.hints.logDoorbell) {
-                    this.log.info("Doorbell ring detected.");
-                }
+                this.handleDoorbellRing(packet);
                 break;
             case "access.remote_view.change":
-                // Process the cancellation of an Access ring event if we're the intended target.
-                if (this.doorbellRingRequestId !== packet.data.remote_call_request_id) {
-                    break;
-                }
-                this.doorbellRingRequestId = null;
-                // Update our doorbell trigger, if needed.
-                this.accessory.getServiceById(this.hap.Service.Switch, AccessReservedNames.SWITCH_DOORBELL_TRIGGER)?.updateCharacteristic(this.hap.Characteristic.On, false);
-                // Publish to MQTT, if configured to do so.
-                this.controller.mqtt?.publish(this.id, "doorbell", "false");
-                if (this.hints.logDoorbell) {
-                    this.log.info("Doorbell ring cancelled.");
-                }
+                this.handleDoorbellCancel(packet);
                 break;
             default:
                 break;
@@ -639,8 +1345,9 @@ export class AccessHub extends AccessDevice {
     // 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) {
+        // We define the specific sensor input properties we need. We skip DPS since we implement it with a manual getter/setter that provides fallback behavior when the
+        // DPS contact sensor is disabled.
+        for (const input of sensorInputs.filter(i => i !== "Dps")) {
             let propName = "hk" + input + "State";
             const enumKey = "CONTACT_" + input.toUpperCase();
             Object.defineProperty(AccessHub.prototype, propName, {