isy-nodejs 1.0.1-alpha.5 → 1.0.1-alpha.9

package/src/Devices/Insteon/InsteonBaseDevice.ts

@@ -1,5 +1,5 @@
 import 'winston';
-import { Converters } from '../../Converters.js';
+import { Converter } from '../../Converters.js';
 import type { Command } from '../../Definitions/Global/Commands.js';
 import { Driver, DriverType } from '../../Definitions/Global/Drivers.js';
 import { Family, Insteon } from '../../Definitions/Global/Families.js';
@@ -38,7 +38,7 @@ export class InsteonBaseDevice<D extends ISYNode.DriverSignatures = {}, C extend
 			case UOM.DegreeX2:
 				return byteToDegree(value);
 			case UOM.LevelFrom0To255:
-				return Converters.Standard.LevelFrom0To255.Percent.to(value);
+				return Converter.Standard.LevelFrom0To255.Percent.to(value);
 			case UOM.Fahrenheit:
 				return value / 10;
 			default:

package/src/Devices/Insteon/InsteonFanDevice.ts

@@ -6,12 +6,12 @@ import { InsteonBaseDevice } from './InsteonBaseDevice.js';
 import { InsteonDimmableDevice } from './InsteonDimmableDevice.js';
 import 'winston';
 import type { NodeInfo, StaticNodeInfo } from '../../Model/NodeInfo.js';
-import {Insteon} from './index.js';
-import  { Command, Driver, UnitOfMeasure } from '../../Definitions/index.js';
+import { Insteon } from './index.js';
+import { Command, Driver, UnitOfMeasure } from '../../Definitions/index.js';
 import type { DriverState } from '../../Model/DriverState.js';
 
 export class InsteonFanMotorDevice extends InsteonBaseDevice<Driver.Signatures<'ST'>, Command.Signatures<'DON' | 'DOF'>> {
-	constructor (isy: ISY, deviceNode: StaticNodeInfo) {
+	constructor(isy: ISY, deviceNode: StaticNodeInfo) {
 		super(isy, deviceNode);
 		this.drivers.ST = Driver.create('ST', this, deviceNode.property as DriverState, { uom: UnitOfMeasure.Percent, label: 'Fan Speed (%)', name: 'fanSpeed' });
 		this.hidden = true;
@@ -25,7 +25,7 @@ export class InsteonFanMotorDevice extends InsteonBaseDevice<Driver.Signatures<'
 	}
 
 	public async updateFanSpeed(level: number) {
-		return (level);
+		return level;
 	}
 	public async updateIsOn(isOn: boolean) {
 		if (!isOn) {
@@ -34,7 +34,6 @@ export class InsteonFanMotorDevice extends InsteonBaseDevice<Driver.Signatures<'
 			//return this.commands.BEEP(States.Level.Max);
 		}
 	}
-
 }
 
 export class InsteonFanDevice extends InsteonBaseDevice {
@@ -43,11 +42,11 @@ export class InsteonFanDevice extends InsteonBaseDevice {
 	constructor(isy: ISY, deviceNode: NodeInfo) {
 		super(isy, deviceNode);
 		this.light = new InsteonDimmableDevice(isy, deviceNode);
-		this.light.events.on('PropertyChanged', ((a: any, b: any, c: any, d: string) => { this.emit('PropertyChanged', `light.${a}`, b, c, d); }).bind(this));
+		/*this.light.events.on('PropertyChanged', ((a: any, b: any, c: any, d: string) => { this.emit('PropertyChanged', `light.${a}`, b, c, d); }).bind(this));*/
 		this.addChild(this.light);
 	}
 
-	public override handleEvent(event: { control?: string; data?: any; node?: any; }): boolean {
+	public override handleEvent(event: { control?: string; data?: any; node?: any }): boolean {
 		this.logger(JSON.stringify(event));
 		const child = this.children.find((p) => p.address === event.node);
 		if (child !== undefined) {
@@ -61,13 +60,16 @@ export class InsteonFanDevice extends InsteonBaseDevice {
 		if (childDevice instanceof InsteonFanMotorDevice) {
 			this.logger('Fan Motor Found');
 			this.motor = childDevice as InsteonFanMotorDevice;
-			this.motor.events.on('statusChanged', ((a: any, b: any, c: any, d: string) => { this.emit('PropertyChanged', `motor.${a}`, b, c, d); }).bind(this));
+			this.motor.events.on(
+				'statusChanged',
+				((a: any, b: any, c: any, d: string) => {
+					this.emit('propertyChanged', `motor.${a}`, b, c, d);
+				}).bind(this)
+			);
 		}
 	}
 
 	public async updateFanSpeed(level: number) {
 		return this.motor.updateFanSpeed(level);
 	}
-
-
 }

package/src/Devices/Insteon/InsteonMotionSensorDevice.ts

@@ -16,13 +16,13 @@ export class InsteonMotionSensorDevice extends InsteonBaseDevice {
 			if (controlName === Commands.On) {
 				this.logger('Motion detected.');
 				this._isMotionDetected = true;
-				this.emit('ControlTriggered',controlName);
-				this.emit('PropertyChanged', 'motionDetected', true, false, "true");
+				this.emit('controlTriggered',controlName);
+				this.emit('propertyChanged', 'motionDetected', true, false, "true");
 
 				setTimeout(() => {
 					this.logger('No motion detected in last 30 seconds.');
 					this._isMotionDetected = false;
-					this.emit('PropertyChanged', 'motionDetected', false, true, "false"); /*Included for compatiblity purposes*/
+					this.emit('propertyChanged', 'motionDetected', false, true, "false"); /*Included for compatiblity purposes*/
 				}, 30000);
 				return true;
 			}
@@ -30,8 +30,8 @@ export class InsteonMotionSensorDevice extends InsteonBaseDevice {
 			else if (controlName === Commands.Off) {
 				this._isMotionDetected = false;
 				this.logger('No motion detected.');
-				this.emit('ControlTriggered',controlName);
-				this.emit('PropertyChanged', 'motionDetected', false, true, "false");
+				this.emit('controlTriggered',controlName);
+				this.emit('propertyChanged', 'motionDetected', false, true, "false");
 				return true;
 			}
 

package/src/Devices/Insteon/InsteonRelayDevice.ts

@@ -7,6 +7,7 @@ import { InsteonBaseDevice } from './InsteonBaseDevice.js';
 
 import type { OnOffBehavior } from '@project-chip/matter.js/behaviors/on-off';
 import 'winston';
+import { RelayLampSwitch } from './RelayLampSwitch.js';
 import type { Command } from '../../Definitions/Global/Commands.js';
 import { Driver, DriverType } from '../../Definitions/Global/Drivers.js';
 import { UnitOfMeasure } from '../../Definitions/index.js';
@@ -14,15 +15,11 @@ import { Properties } from '../../ISYConstants.js';
 
 import type { DriverState } from '../../Model/DriverState.js';
 
-export class InsteonRelayDevice extends InsteonBaseDevice<Driver.Signatures<'ST' | 'OL' | 'RR' | 'ERR'>, Command.Signatures<'DON' | 'DOF'>> {
+export class InsteonRelayDevice extends RelayLampSwitch.Node /*InsteonBaseDevice<Driver.Signatures<'ST' | 'OL' | 'RR' | 'ERR'>, Command.Signatures<'DON' | 'DOF'>>*/ {
 	// #region Constructors (1)
 
 	constructor(isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create('ST', this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: 'Status', name: 'status' });
-		this.drivers.OL = Driver.create('OL', this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: 'On Level', name: 'onLevel' });
-		this.drivers.RR = Driver.create('RR', this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: 'Ramp Rate', name: 'rampRate' });
-		this.drivers.ERR = Driver.create('ERR', this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: 'Error', name: 'error' });
 	}
 
 	// #endregion Constructors (1)
@@ -58,7 +55,7 @@ export class InsteonRelayDevice extends InsteonBaseDevice<Driver.Signatures<'ST'
 
 	} */
 	public override async sendBeep(level: number = 100): Promise<any> {
-		return super.sendBeep(level);
+		return super.beep(level);
 	}
 
 	// #endregion Public Methods (2)

package/src/Devices/Insteon/RelayLampSwitch.ts

@@ -0,0 +1,131 @@
+/* THIS FILE WAS AUTOMATICALLY GENERATED. DO NOT EDIT DIRECTLY. */
+
+import { UnitOfMeasure } from "../../Definitions/Global/UOM.js";
+import { Family } from "../../Definitions/Global/Families.js";
+import type { NodeInfo } from "../../Model/NodeInfo.js";
+import type { ISY } from "../../ISY.js";
+import type { ISYNode } from "../../ISYNode.js";
+import { InsteonBaseDevice } from "./InsteonBaseDevice.js";
+import { ISYDeviceNode } from "../ISYDeviceNode.js";
+import { Driver } from "../../Definitions/Global/Drivers.js";
+import { Insteon } from "../../Definitions/index.js";
+import type { DriverState } from "../../Model/DriverState.js";
+import { NodeFactory } from "../NodeFactory.js";
+
+export const nodeDefId = "RelayLampSwitch";
+
+type Commands = RelayLampSwitch.Commands;
+type Drivers = RelayLampSwitch.Drivers;
+
+export class RelayLampSwitchNode extends InsteonBaseDevice<Drivers, Commands> implements RelayLampSwitch.Interface {
+	public override readonly commands = {
+		DON: this.on,
+		DOF: this.off,
+		DFOF: this.fastOff,
+		DFON: this.fastOn,
+		QUERY: this.query,
+		BEEP: this.beep,
+		BL: this.backlight,
+		WDU: this.writeChanges
+	};
+	static override nodeDefId = 'RelayLampSwitch';
+	declare readonly nodeDefId: 'RelayLampSwitch';
+	constructor(isy: ISY, nodeInfo: NodeInfo) {
+		super(isy, nodeInfo);
+		this.drivers.ST = Driver.create('ST', this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: 'Status', name: 'status' });
+		this.drivers.ERR = Driver.create('ERR', this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: 'Responding', name: 'responding' });
+	}
+	async on(value?: 0 | 100) {
+		return this.sendCommand('DON', { value: value });
+	}
+	async off() {
+		return this.sendCommand('DOF');
+	}
+	async fastOff() {
+		return this.sendCommand('DFOF');
+	}
+	async fastOn() {
+		return this.sendCommand('DFON');
+	}
+	async query() {
+		return this.sendCommand('QUERY');
+	}
+	async beep(value?: number) {
+		return this.sendCommand('BEEP', { value: value });
+	}
+	async backlight(value: number) {
+		return this.sendCommand('BL', { value: value });
+	}
+	async writeChanges() {
+		return this.sendCommand('WDU');
+	}
+	public get status(): Insteon.OnLevelRelay {
+		return this.drivers.ST?.value;
+	}
+	public get responding(): Insteon.Error {
+		return this.drivers.ERR?.value;
+	}
+}
+
+NodeFactory.register(RelayLampSwitchNode);
+
+export namespace RelayLampSwitch {
+	export interface Interface extends Omit<InstanceType<typeof RelayLampSwitchNode>, keyof ISYDeviceNode<any, any, any, any>> {
+		nodeDefId: "RelayLampSwitch";
+	}
+	export function is(node: ISYNode<any, any, any, any>): node is RelayLampSwitchNode {
+		return node.nodeDefId === nodeDefId;
+	}
+	export function create(isy: ISY, nodeInfo: NodeInfo) {
+		return new RelayLampSwitchNode(isy, nodeInfo);
+	}
+	export const Node = RelayLampSwitchNode;
+	export type Commands = {
+		DON: ((value?: (0 | 100)) => Promise<boolean>) & {
+			label: "On";
+			name: "on";
+		};
+		DOF: (() => Promise<boolean>) & {
+			label: "Off";
+			name: "off";
+		};
+		DFOF: (() => Promise<boolean>) & {
+			label: "Fast Off";
+			name: "fastOff";
+		};
+		DFON: (() => Promise<boolean>) & {
+			label: "Fast On";
+			name: "fastOn";
+		};
+		QUERY: (() => Promise<boolean>) & {
+			label: "Query";
+			name: "query";
+		};
+		BEEP: ((value?: number) => Promise<boolean>) & {
+			label: "Beep";
+			name: "beep";
+		};
+		BL: ((value: number) => Promise<boolean>) & {
+			label: "Backlight";
+			name: "backlight";
+		};
+		WDU: (() => Promise<boolean>) & {
+			label: "Write Changes";
+			name: "writeChanges";
+		};
+	};
+	export type Drivers = {
+		ST: {
+			uom: UnitOfMeasure.Percent;
+			value: Insteon.OnLevelRelay;
+			label: "Status";
+			name: "status";
+		};
+		ERR: {
+			uom: UnitOfMeasure.Index;
+			value: Insteon.Error;
+			label: "Responding";
+			name: "responding";
+		};
+	};
+}

package/src/ISY.ts

@@ -10,7 +10,6 @@ import { EventEmitter } from 'events';
 import winston, { format, Logger, loggers, type LeveledLogMethod } from 'winston';
 import { Category } from './Definitions/Global/Categories.js';
 import { Family } from './Definitions/Global/Families.js';
-import type { NodeInfo } from './Model/NodeInfo.js';
 import { DeviceFactory } from './Devices/DeviceFactory.js';
 import { ELKAlarmPanelDevice } from './Devices/Elk/ElkAlarmPanelDevice.js';
 import { ElkAlarmSensorDevice } from './Devices/Elk/ElkAlarmSensorDevice.js';
@@ -31,13 +30,14 @@ import { InsteonOnOffOutletDevice } from './Devices/Insteon/InsteonOnOffOutletDe
 import { InsteonRelayDevice } from './Devices/Insteon/InsteonRelayDevice.js';
 import { InsteonSmokeSensorDevice } from './Devices/Insteon/InsteonSmokeSensorDevice.js';
 import { InsteonThermostatDevice } from './Devices/Insteon/InsteonThermostatDevice.js';
+import { ISYDeviceNode } from './Devices/ISYDeviceNode.js';
 import { EventType } from './Events/EventType.js';
 import { NodeType, Props, States, VariableType } from './ISYConstants.js';
-import { ISYNode } from './ISYNode.js';
-import { ISYDeviceNode } from './Devices/ISYDeviceNode.js';
 import { type ISYDevice } from './ISYDevice.js';
+import { ISYNode } from './ISYNode.js';
 import { ISYScene } from './ISYScene.js';
 import { ISYVariable } from './ISYVariable.js';
+import type { NodeInfo } from './Model/NodeInfo.js';
 
 import * as Utils from './Utils.js';
 
@@ -118,6 +118,21 @@ const parser = new Parser(defaultParserOptions);
 
 export let Controls = {};
 
+interface ISYConfig {
+	// #region Properties (8)
+
+	displayNameFormat?: string;
+	elkEnabled?: boolean;
+	enableWebSocket?: boolean;
+	host: string;
+	password: string;
+	port: number;
+	protocol: 'http' | 'https';
+	username: string;
+
+	// #endregion Properties (8)
+}
+
 export class ISY extends EventEmitter implements Disposable {
 	// #region Properties (30)
 
@@ -158,20 +173,7 @@ export class ISY extends EventEmitter implements Disposable {
 
 	// #region Constructors (1)
 
-	constructor(
-		config: {
-			host: string;
-			port: number;
-			protocol: 'http' | 'https';
-			username: string;
-			password: string;
-			enableWebSocket?: boolean;
-			displayNameFormat?: string;
-			elkEnabled?: boolean;
-		},
-		logger: Logger = new Logger(),
-		storagePath?: string
-	) {
+	constructor(config: ISYConfig, logger: Logger = new Logger(), storagePath?: string) {
 		super();
 		this.enableWebSocket = config.enableWebSocket ?? true;
 		this.storagePath = storagePath ?? './';
@@ -218,7 +220,15 @@ export class ISY extends EventEmitter implements Disposable {
 
 	// #endregion Public Getters And Setters (2)
 
-	// #region Public Methods (22)
+	// #region Public Methods (24)
+
+	[Symbol.dispose](): void {
+		try {
+			this.webSocket?.close();
+		} catch (e) {
+			this.logger.error(`Error closing websocket: ${e.message}`);
+		}
+	}
 
 	public override emit(event: 'InitializeCompleted' | 'NodeAdded' | 'NodeRemoved' | 'NodeChanged', node?: ISYNode<any, any, any, any>): boolean {
 		return super.emit(event, node);
@@ -239,6 +249,10 @@ export class ISY extends EventEmitter implements Disposable {
 		return s as T;
 	}
 
+	public getElkAlarmPanel() {
+		return this.elkAlarmPanel;
+	}
+
 	public getNode<T extends ISYNode<any, any, any, any> = ISYNode<any, any, any, any>>(address: string, parentsOnly = false): T {
 		let s = this.nodeMap.get(address);
 		if (!parentsOnly) {
@@ -254,10 +268,6 @@ export class ISY extends EventEmitter implements Disposable {
 		return s as T;
 	}
 
-	public getElkAlarmPanel() {
-		return this.elkAlarmPanel;
-	}
-
 	public getScene(address: string) {
 		return this.sceneList.get(address);
 	}
@@ -569,12 +579,13 @@ export class ISY extends EventEmitter implements Disposable {
 			trailingSlash: boolean;
 			requestLogLevel?: any;
 			responseLogLevel?: any;
+			errorLogLevel?: any;
 		} = { trailingSlash: true }
 	): Promise<any> {
-		const requestLogLevel = options.requestLogLevel ?? winston.config.cli.levels.debug;
-		const responseLogLevel = options.responseLogLevel ?? winston.config.cli.levels.silly;
+		const requestLogLevel = options.requestLogLevel ?? 'debug';
+		const responseLogLevel = options.responseLogLevel ?? 'silly';
 		url = `${this.protocol}://${this.address}/rest/${url}${options.trailingSlash ? '/' : ''}`;
-		this.logger.log(`Sending request: ${url}`, requestLogLevel);
+		this.logger.log(requestLogLevel, `Sending request: ${url}`);
 		try {
 			const response = await axios.get(url, {
 				auth: { username: this.credentials.username, password: this.credentials.password }
@@ -585,19 +596,22 @@ export class ISY extends EventEmitter implements Disposable {
 					if (options.parserOptions) curParser = new Parser({ ...defaultParserOptions, ...options.parserOptions });
 					var altParser = new XMLParser(defaultXMLParserOptions);
 					var s = altParser.parse(response.data);
-					this.logger.log(`Response: ${JSON.stringify(s)}`, requestLogLevel ?? 'debug');
+					this.logger.log(requestLogLevel ?? 'debug', `Response: ${JSON.stringify(s)}`);
 					return s;
 				} else if (response.headers['content-type'].toString().includes('json')) {
-					this.logger.log(`Response: ${JSON.stringify(response.data)}`, requestLogLevel ?? 'debug');
+					this.logger.log(responseLogLevel ?? 'debug', `Response: ${JSON.stringify(response.data)}`);
 					return JSON.parse(response.data);
 				} else {
-					this.logger.log(`Response Header: ${JSON.stringify(response.headers)} Response: ${JSON.stringify(response.data)}`, responseLogLevel ?? 'debug');
+					this.logger.log(responseLogLevel ?? 'debug', `Response Header: ${JSON.stringify(response.headers)} Response: ${JSON.stringify(response.data)}`);
 					return response.data;
 				}
 			}
 		} catch (error) {
-			this.logger.error(`Error sending request to ISY: ${error?.message}`);
-			throw new Error(`Error sending request to ISY: ${JSON.stringify(error)}`);
+			if (options.errorLogLevel) {
+				this.logger.log(options.errorLogLevel, `Error sending request to ISY: ${error?.message}`);
+			} else {
+				this.logger.error(`Error sending request to ISY: ${error?.message}`);
+			}
 		}
 	}
 
@@ -608,11 +622,15 @@ export class ISY extends EventEmitter implements Disposable {
 		return this.sendRequest(uriToUse);
 	}
 
-	public variableChangedHandler(variable: { id: string; type: string }) {
+	#variableChangedHandler(variable: { id: string; type: string }) {
 		this.logger.info(`Variable: ${variable.id} (${variable.type}) changed`);
 	}
 
-	// #endregion Public Methods (22)
+	public close() {
+		if (this.webSocket) this.webSocket.close();
+	}
+
+	// #endregion Public Methods (24)
 
 	// #region Private Methods (11)
 
@@ -649,12 +667,13 @@ export class ISY extends EventEmitter implements Disposable {
 		}
 	}
 
-	#guardian() {
+	async #guardian() {
 		const timeNow = new Date();
 
 		if (Number(timeNow) - Number(this.lastActivity) > 60000) {
 			this.logger.info('Guardian: Detected no activity in more then 60 seconds. Reinitializing web sockets');
-			this.initializeWebSocket();
+			await this.refreshStatuses();
+			await this.initializeWebSocket();
 		}
 	}
 
@@ -802,13 +821,9 @@ export class ISY extends EventEmitter implements Disposable {
 		}
 	}
 
-	[Symbol.dispose](): void {
-		try {
-			this.webSocket.close();
-		} catch (e) {
-			this.logger.error(`Error closing websocket: ${e.message}`);
-		}
-	}
-
 	// #endregion Private Methods (11)
 }
+
+export namespace ISY {
+	export interface Config extends ISYConfig {}
+}

package/src/ISYNode.ts

@@ -6,7 +6,7 @@ import { UnitOfMeasure } from './Definitions/Global/UOM.js';
 import { ISY, NodeType, type ISYScene } from './ISY.js';
 
 import { CliConfigSetLevels } from 'winston/lib/winston/config/index.js';
-import { Converters } from './Converters.js';
+import { Converter } from './Converters.js';
 import type { Command } from './Definitions/Global/Commands.js';
 import { Event } from './Definitions/Global/Events.js';
 import type { Constructor } from './Devices/Constructor.js';
@@ -168,7 +168,7 @@ export class ISYNode<
 		if (from === to) return value;
 		else {
 			try {
-				return Converters.Standard[from][to].from(value);
+				return Converter.Standard[from][to].from(value);
 			} catch {
 				this.isy.logger.error(`Conversion from ${UnitOfMeasure[from]} to ${UnitOfMeasure[to]} not supported.`);
 			} finally {
@@ -191,7 +191,7 @@ export class ISYNode<
 		}
 	}
 
-	public emit(event: 'PropertyChanged' | 'ControlTriggered', propertyName?: string, newValue?: any, oldValue?: any, formattedValue?: string, controlName?: string) {
+	public emit(event: 'propertyChanged' | 'controlTriggered', propertyName?: string, newValue?: any, oldValue?: any, formattedValue?: string, controlName?: string) {
 		//if ('PropertyChanged') return super.emit(event, propertyName, newValue, oldValue, formattedValue);
 		//else if ('ControlTriggered') return super.emit(event, controlName);
 	}
@@ -232,7 +232,7 @@ export class ISYNode<
 
 	public handleControlTrigger(controlName: keyof E & keyof C): boolean {
 		//this.lastChanged = new Date();
-		this.events.emit('ControlTriggered', controlName);
+		this.events.emit('controlTriggered', controlName);
 		return true;
 	}
 
@@ -253,22 +253,25 @@ export class ISYNode<
 		} else {
 			// this.logger(event.control);
 			const e = event.control;
-			const dispName = this.commands[e].name;
+			const dispName = this.commands[e]?.name;
 			if (dispName !== undefined && dispName !== null) {
-				this.logger(`Command ${dispName} (${e}) triggered.`);
+				this.logger(`Command ${dispName} (${e}) event sent.`);
 			} else {
-				this.logger(`Command ${e} triggered.`);
+				this.logger(`Command ${e} event sent.`);
 			}
 			this.handleControlTrigger(e);
 			return true;
 		}
 	}
 
-	public handlePropertyChange(propertyName: StringKeys<D>, value: any, uom: UnitOfMeasure, formattedValue: string, prec?: number): boolean {
+	public handlePropertyChange(propertyName: StringKeys<D>, value: any, uom: UnitOfMeasure, prec?: number, formattedValue?: string): boolean {
 		this.lastChanged = new Date();
-		const oldValue = this.drivers[propertyName].value;
-		if (this.drivers[propertyName].patch(value, formattedValue, uom, prec)) {
-			this.emit('PropertyChanged', propertyName, value, oldValue, formattedValue);
+		let driver = this.drivers[propertyName];
+		this.logger(`Driver ${propertyName} (${driver?.label} value update ${value} (${formattedValue}) uom: ${UnitOfMeasure[uom]} event received.`);
+		const oldValue = driver?.value;
+		if (driver?.patch(value, formattedValue, uom, prec)) {
+			this.logger(`Driver ${driver.label} updated from ${oldValue} to ${value} (${formattedValue})`);
+			this.emit('propertyChanged', propertyName, value, oldValue, formattedValue);
 			this.scenes?.forEach((element) => {
 				this.logger(`Recalulating ${element.deviceFriendlyName}`);
 				element.recalculateState();

package/src/ISYScene.ts

@@ -77,7 +77,7 @@ export class ISYScene extends ISYNode<Family.Scene, Driver.Signatures<'ST'>,Comm
 	get isOn() {
 		for (const device of this.members) {
 			if (device instanceof Insteon.Relay)  {
-				if (device.drivers.ST?.value === 1) {
+				if (device.drivers.ST?.value != 0) {
 					return true;
 				}
 			}
@@ -110,10 +110,10 @@ export class ISYScene extends ISYNode<Family.Scene, Driver.Signatures<'ST'>,Comm
 	}
 	public markAsChanged() {
 		this.lastChanged = new Date();
-		this.emit('PropertyChanged', 'isOn', this.isOn, this.isOn, this.isOn ? 'on' : 'off');
+		this.emit('propertyChanged', 'isOn', this.isOn, this.isOn, this.isOn ? 'on' : 'off');
 
 		if (this.isDimmable) {
-			this.emit('PropertyChanged', 'brightnesslevel', this.brightnessLevel, this.brightnessLevel, this.brightnessLevel + '%');
+			this.emit('propertyChanged', 'brightnesslevel', this.brightnessLevel, this.brightnessLevel, this.brightnessLevel + '%');
 
 		}
 	}

package/src/Matter/Behaviors/ISYBridgedDeviceBehavior.ts

@@ -11,11 +11,11 @@ import internal from 'stream';
 import type { Driver } from '../../Definitions/Global/Drivers.js';
 import { ISY, type Family, type ISYNode } from '../../ISY.js';
 import type { ISYDevice } from '../../ISYDevice.js';
-import { DeviceToClusterMap, MappingRegistry, type ClusterMapping } from '../../Model/ClusterMap.js';
+import { DeviceToClusterMap, MappingRegistry, type ClusterMapping, type BehaviorMapping } from '../../Model/ClusterMap.js';
 
 
 type ClusterForBehavior<B extends ClusterBehavior> = B extends ClusterBehavior.Type<infer C> ? C : never;
-export class ISYBridgedDeviceBehavior extends Behavior {
+export class ISYBridgedDeviceBehavior<N extends ISYNode<any, D, any, any>, D extends ISYNode.DriverSignatures = ISYNode.DriverSignatures> extends Behavior {
 	static override readonly id = 'isyNode';
 
 	static override readonly early = true;
@@ -23,16 +23,24 @@ export class ISYBridgedDeviceBehavior extends Behavior {
 	declare internal: ISYBridgedDeviceBehavior.Internal;
 	declare state: ISYBridgedDeviceBehavior.State;
 
-	declare events: ISYBridgedDeviceBehavior.Events;
+	declare events: ISYBridgedDeviceBehavior.Events & ISYBridgedDeviceBehavior.EventsFor<N["drivers"]>;
 
 	override async initialize(_options?: {}) {
 		await super.initialize(_options);
 		var address = this.state.address;
-		this.internal.device = ISY.instance.nodeMap.get(this.state.address);
-		this.internal.map = MappingRegistry.getMapping(this.internal.device as unknown as ISYDevice<Family, any, any, any>);
+		const d = ISY.instance.nodeMap.get(this.state.address);
+		this.internal.device = d;
+		this.internal.map = MappingRegistry.getMapping(this.internal.device as unknown as ISYNode<Family, any, any, any>);
 		ISY.instance.logger.debug(`Initializing ${this.constructor.name} for ${this.internal.device.constructor.name} ${this.internal.device.name} with address ${address}`);
-		if (this.internal.device) {
-			this.internal.device.events.on('PropertyChanged', this.handlePropertyChange.bind(this));
+		if (d) {
+			d.events.on('PropertyChanged', this.handlePropertyChange.bind(this));
+			for(const f in d.drivers)
+			{
+				let evt = `${d.drivers[f].name}Changed`;
+				this.events[evt] = Observable<[{ driver: string; newValue: any; oldValue: any; formattedValue: string }]>();
+				//@ts-ignore
+				d.events.on(evt, (driver: string, newValue: any, oldValue: any, formattedValue: string) => this.events.emit(evt, { driver, newValue, oldValue, formattedValue } as unknown as any));
+			}
 		}
 	}
 
@@ -44,15 +52,15 @@ export class ISYBridgedDeviceBehavior extends Behavior {
 		return this.internal.map;
 	}
 
-	mapForBehavior<B extends { cluster: unknown }>(behavior: B): ClusterMapping<B['cluster'], typeof this.internal.device> {
-		return this.map[behavior.cluster['name']];
+	mapForBehavior<B extends ClusterBehavior>(behavior: B): BehaviorMapping<B, typeof this.internal.device> {
+		return this.map.mapping[behavior.cluster['name']];
 	}
 
 	handlePropertyChange(driver: string, newValue: any, oldValue: any, formattedValue: string) {
 		this.events.propertyChanged.emit({ driver, newValue, oldValue, formattedValue });
 	}
 
-	[Symbol.asyncDispose]() {
+	override [Symbol.asyncDispose]() {
 		this.internal.device = null;
 		return super[Symbol.asyncDispose]();
 	}
@@ -64,8 +72,18 @@ export namespace ISYBridgedDeviceBehavior {
 		map?: DeviceToClusterMap<typeof this.device, any>;
 	}
 
-	export class Events extends EventEmitter {
+	export type EventsFor<D extends {[x: string]: Driver<any,any,any>}> = {
+		[s in keyof D as `${D[s]["name"]}Changed`] : Observable<[{ driver: s; newValue: any; oldValue: any; formattedValue: string }]>;
+	}
+
+
+
+
+	export class Events extends EventEmitter{
 		propertyChanged = Observable<[{ driver: string; newValue: any; oldValue: any; formattedValue: string }]>();
+
+
+
 	}
 
 	export class State {