isy-nodejs 1.0.1-alpha.2 → 1.0.1-alpha.20

package/package.json

@@ -2,7 +2,7 @@
     "name": "isy-nodejs",
     "description": "Node.js wrapper for ISY interface including websockets for change notifications. Fork of isy-js by Rod Toll. Designed to be used in a node.js application.",
     "license": "MIT",
-    "version": "1.0.1-alpha.2",
+    "version": "1.0.1-alpha.20",
     "author": {
         "name": "Pradeep Mouli"
     },
@@ -46,6 +46,7 @@
         "@types/node": "^22.7.5",
         "@types/xml2js": "",
         "@types/xmldoc": "",
+        "microdiff": "^1.4.0",
         "mocha": "",
         "rimraf": "^6.0.1"
     },
@@ -56,6 +57,7 @@
         "axios": "^1.7.7",
         "fast-xml-parser": "^4.5.0",
         "faye-websocket": "^0.11.4",
+        "install": "^0.13.0",
         "mocha": "^10.7.3",
         "p-queue": "^8.0.1",
         "winston": "^3.15.0",
@@ -64,12 +66,8 @@
     "bugs": {
         "url": "https://github.com/pradeepmouli/isy-nodejs/issues"
     },
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/pradeepmouli/isy-js.git"
-    },
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "8004f489e0ea150182931c54a999bf90f941d829"
+    "gitHead": "3b8710c1b6a783c32744c2f97f56ba8b836b02ca"
 }

package/src/Converters.ts

@@ -1,87 +1,155 @@
-import { UnitOfMeasure } from "./Definitions/Global/UOM.js";
-import { Converter, invert } from './Utils.js';
+
+import { UnitOfMeasure } from './Definitions/Global/UOM.js';
+import { type StringKeys } from './Utils.js';
 
 let BooleanPercentage: Converter<boolean, number>;
+let NullConverter: Converter<any, any>;
+{
+	to: (value: any) => value;
+	from: (value: any) => value;
+}
 
 BooleanPercentage = {
-  to: (value: number): boolean => {
-    return value > 0;
-  },
-  from: (value: boolean): number => {
-    return value ? 100 : 0;
-  },
+	to: (value: number): boolean => {
+		return value > 0;
+	},
+	from: (value: boolean): number => {
+		return value ? 100 : 0;
+	}
 };
 
-const StandardConverters : {
-    [x in `${keyof typeof UnitOfMeasure}`]?: { [y in `${keyof typeof UnitOfMeasure}`]?: Converter<any, any> };
-  }  = {
-  Boolean: {
-    LevelFrom0To255: {
-      from: (value: number) => value > 0,
-      to: (value: boolean) => (value ? 255 : 0),
-    },
-    Percent: BooleanPercentage,
-  },
-  Percent: {},
-  LevelFrom0To255: {
-    Percent: {
-      to: (value: number): number => {
-        return Math.round((value * 255) / 100);
-      },
-      from: (value: number): number => {
-        return Math.round((value * 100) / 255);
-      },
-    },
-  },
+const StandardConverters: {
+	[x in `${keyof typeof UnitOfMeasure}`]?: { [y in `${keyof typeof UnitOfMeasure}`]?: Converter<any, any> };
+} = {
+	Boolean: {
+		LevelFrom0To255: {
+			to: (value: boolean) => (value ? 255 : 0),
+			from: (value: number) => value > 0
+		},
+		Percent: BooleanPercentage
+	},
+	Percent: {},
+	LevelFrom0To255: {
+		Percent: {
+			to: (value: number): number => {
+				return Math.round((value * 100) / 255);
+			},
+			from: (value: number): number => {
+				return Math.round((value * 255) / 100);
+			}
+		}
+	}
 };
 
 StandardConverters.Percent.LevelFrom0To255 = invert(StandardConverters.LevelFrom0To255.Percent);
 StandardConverters.LevelFrom0To255.Boolean = invert(StandardConverters.Boolean.LevelFrom0To255);
 
-export const ConverterRegistry = new Map<UnitOfMeasure, Map<UnitOfMeasure, Converter<any, any>>>();
+export const StdConverterRegistry = new Map<UnitOfMeasure | string, Map<UnitOfMeasure | string, Converter<any, any>>>();
 
-function registerConverters(){
-  for (const from in StandardConverters) {
-    for (const to in StandardConverters[from]) {
-      registerConverter(UnitOfMeasure[from], UnitOfMeasure[to], StandardConverters[from][to] as Converter<any, any>);
-    }
-  }
+export const ConverterRegistry = new Map<string, Converter<any, any>>();
+
+function registerConverters() {
+	for (const from in StandardConverters) {
+		for (const to in StandardConverters[from]) {
+			registerConverter(UnitOfMeasure[from], UnitOfMeasure[to], StandardConverters[from][to] as Converter<any, any>);
+			registerConverter(UnitOfMeasure[to], UnitOfMeasure[from], invert(StandardConverters[from][to]) as Converter<any, any>);
+		}
+	}
+	for (const from in Converter.Matter) {
+		for (const to in Converter.Matter[from]) {
+			registerConverter(from, to, Converter.Matter[from][to] as Converter<any, any>);
+			registerConverter(to, from, invert(Converter.Matter[from][to]) as Converter<any, any>);
+		}
+	}
 }
 
-export function registerConverter(from: UnitOfMeasure, to: UnitOfMeasure, converter: Converter<any, any>)
-{
-  if (!ConverterRegistry.has(from)) {
-    ConverterRegistry.set(from, new Map());
-  }
-  ConverterRegistry.get(from).set(to, converter);
+export function registerConverter(
+	from: keyof typeof StandardConverters | UnitOfMeasure | keyof typeof Converter.Matter | string,
+	to: keyof typeof StandardConverters | UnitOfMeasure | keyof typeof Converter.Matter | string,
+	converter: Converter<any, any>
+) {
+	if (!StdConverterRegistry.has(from)) {
+		StdConverterRegistry.set(from, new Map());
+	}
+
+	StdConverterRegistry.get(from).set(to, converter);
+	let key = from + '.' + to;
+	if (!ConverterRegistry.has(key)) {
+		ConverterRegistry.set(key, converter);
+	}
 }
 
-export namespace Converters {
-  export const Standard : typeof StandardConverters = StandardConverters;
-
-  export const Matter: { [x in `${keyof typeof UnitOfMeasure}`]?: { [y: string]: Converter<any, any> } } = {
-    LevelFrom0To255: {
-      LightingLevel: {
-        from: (value) => (value === 1 ? 0 : value === 254 ? 255 : value),
-        to: (value) => (value === 0 ? 1 : value === 255 ? 254 : value),
-      },
-    }
-  };
-
-  export function getConverter(from: UnitOfMeasure, to: UnitOfMeasure): Converter<any, any> {
-    if (!ConverterRegistry.has(from)) {
-      return null;
-    }
-    return ConverterRegistry.get(from).get(to);
-  }
-
-  export function convert<F,T>(from: UnitOfMeasure, to: UnitOfMeasure, value: F): T {
-    const converter = getConverter(from, to);
-    if (converter) {
-      return converter.to(value);
-    }
-    return null;
-  }
+export namespace Converter {
+	export const Standard: typeof StandardConverters = StandardConverters;
+
+	export const Matter = {
+		LevelFrom0To255: {
+			LightingLevel: {
+				from: (value) =>
+					value === 1 ? 0
+					: value === 254 ? 255
+					: value,
+				to: (value) =>
+					value === 0 ? 1
+					: value === 255 ? 254
+					: value
+			}
+		}
+	};
+
+	export type ConverterTypes = `${StringKeys<typeof StandardConverters>}`;
+
+	export type StandardConverters = `${StringKeys<typeof StandardConverters>}.${StringKeys<typeof StandardConverters>}`;
+
+	export type MatterISYConvertibleTypes = `${StringKeys<(typeof Matter)[`${keyof typeof Matter}`]>}`;
+
+	export type ISYMatterConvertibleTypes = `${StringKeys<typeof Matter>}`;
+
+	export type MatterConverters = `${MatterISYConvertibleTypes}.${ISYMatterConvertibleTypes}` | `${ISYMatterConvertibleTypes}.${MatterISYConvertibleTypes}`;
+
+	export type KnownConverters = StandardConverters | MatterConverters;
+
+	export function get(label: KnownConverters): Converter<any, any>;
+	export function get(from: UnitOfMeasure, to: UnitOfMeasure);
+	export function get(from: ConverterTypes, to: ConverterTypes);
+	export function get(from: UnitOfMeasure, to: UnitOfMeasure);
+	export function get(from: MatterISYConvertibleTypes, to: ISYMatterConvertibleTypes);
+	export function get(to: ISYMatterConvertibleTypes, from: MatterISYConvertibleTypes);
+	export function get(from: UnitOfMeasure | `${keyof typeof UnitOfMeasure}` | string, to?: UnitOfMeasure | `${keyof typeof UnitOfMeasure}` | string): Converter<any, any> {
+		let isString = typeof from === 'string';
+		let fuom = isString ? UnitOfMeasure[from] : from;
+		if (to) {
+			let tuom = typeof to === 'string' ? UnitOfMeasure[to] : to;
+
+			if (StdConverterRegistry.has(fuom)) {
+				return StdConverterRegistry.get(fuom).get(tuom);
+			}
+		} else if (typeof from === 'string') {
+			return ConverterRegistry.get(from);
+		}
+		return NullConverter;
+	}
+
+	export function convert<F, T>(from: UnitOfMeasure, to: UnitOfMeasure, value: F): T {
+		const converter = get(from, to);
+		if (converter) {
+			return converter.to(value);
+		}
+		return null;
+	}
 }
 
-registerConverters();
+registerConverters();
+export interface Converter<F, T> {
+	// #region Properties (2)
+	from: (value: F) => T;
+	to: (value: T) => F;
+} //onst D: d = 'ST';
+//type DriverLabel = Values<IdentityOf<DriverType>>;
+
+export function invert<F, T>(converter: Converter<F, T>): Converter<T, F> {
+	return {
+		from: converter.to,
+		to: converter.from
+	};
+}

package/src/Definitions/Global/Drivers.ts

@@ -9,9 +9,10 @@ import type { Identity, MaybePromise, UnionToIntersection } from '@project-chip/
 import exp from 'constants';
 import { init } from 'homebridge';
 import { server } from 'typescript';
+import { Converter } from '../../Converters.js';
 import type { ISYDeviceNode } from '../../Devices/ISYDeviceNode.js';
 import type { DriverState } from '../../Model/DriverState.js';
-import type { Converter, StringKeys } from '../../Utils.js';
+import type { StringKeys } from '../../Utils.js';
 import type { Family } from './Families.js';
 
 export enum DriverType {
@@ -293,7 +294,7 @@ export interface Driver<
 	// #region Public Methods (2)
 
 	apply(state: DriverState, notify?: boolean): boolean;
-	patch(value: T, formattedValue: string, uom: UnitOfMeasure, prec: number): boolean;
+	patch(value: T, formattedValue: string, uom: UnitOfMeasure, prec: number, notify?: boolean): boolean;
 
 	// #endregion Public Methods (2)
 //override on('change', listener: (value: any) => void): this;
@@ -339,7 +340,6 @@ export function isTrue(x: true | false): x is true {
 
 export type DriverTypeLiteral = EnumLiteral<DriverType>;
 
-
 export type EnumWithLiteral<D extends string | bigint | number | boolean> = D | EnumLiteral<D>;
 export namespace Driver {
 	export type Signature<U extends UnitOfMeasure = UnitOfMeasure, V = any, SU = U, N = string, L = N> = { uom: U; value: V; name: N; label: L; serverUom?: SU };
@@ -384,7 +384,7 @@ export namespace Driver {
 	type StatelessOrStateful<D extends string, U extends UnitOfMeasure, T = number, N = string, L = string, S extends boolean = false> =
 		S extends true ? StatelessDriver<D, U, T, U, N, L> : Driver<D, U, T, U, N, L>;
 
-	export function create<D extends Literal, U extends UnitOfMeasure, T = number, L extends string = string, N extends string = string, S extends boolean = false>(
+	export function create<D extends Literal, U extends UnitOfMeasure, T = number,  N extends string = string, L extends string = string, S extends boolean = false>(
 		driver: EnumWithLiteral<D>,
 
 		node?: ISYNode<Family, any, any, any>,
@@ -446,13 +446,22 @@ export namespace Driver {
 				if (notify) node.events.emit(`${this.name}Changed`, driver as D, this.state.value, previousValue, this.state.formattedValue);
 				return true;
 			},
-			patch(value: T, formattedValue: string, uom: UnitOfMeasure, prec: number, notify = false) {
+			patch(value: T, formattedValue: string, uom: UnitOfMeasure, prec: number, notify = true) {
 				let previousValue = this.state.value;
 
 				this.state.formattedValue = formattedValue;
 				if (uom != this.uom) {
-					this.serverUom = uom;
-					this.state.value = converter ? converter.from(value) : node.convertFrom(value, uom, driver as D);
+					this.serverUom == uom;
+					this.state.value = converter ? converter.from(value) : Converter.convert(uom, this.uom, value);
+
+				}
+				else if(converter)
+				{
+					this.state.value = converter.from(value);
+				}
+				else
+				{
+					this.state.value = value;
 				}
 				if (previousValue == this.state.value) {
 					return false;

package/src/Definitions/Global/Events.ts

@@ -52,7 +52,8 @@ export namespace Event {
 
 	constructor(node: N) {
 			super({ captureRejections: true });
-		}
+
+	}
 
 	// #endregion Constructors (1)
 }
@@ -61,8 +62,8 @@ export namespace Event {
 		node: N
 	): FunctionSigFor<E, NodeEventEmitter<N>> & Omit<NodeEventEmitter<N>, 'on'> {
 		var f = new NodeEventEmitter(node);
-		for (let evt in node.events) {
-			const ev = node.events[evt];
+		for (let evt in node.drivers) {
+			
 			//f[`on${ev.name}`] = f.on.bind(f, ev.name);
 		}
 

package/src/Devices/Elk/ElkAlarmPanelDevice.ts

@@ -90,21 +90,21 @@ export class ELKAlarmPanelDevice extends ISYDeviceNode<Family.Global,any,any> {
 				if (this.alarmTripState !== valueToSet) {
 					const oldVal = this.alarmTripState;
 					this.alarmTripState = valueToSet;
-					this.emit('PropertyChanged', 'alarmTripState', this.alarmTripState, oldVal, AlarmTripState[this.alarmTripState]);
+					this.emit('propertyChanged', 'alarmTripState', this.alarmTripState, oldVal, AlarmTripState[this.alarmTripState]);
 					valueChanged = true;
 				}
 			} else if (updateType === AlarmPanelProperty.AlarmState) {
 				if (this.alarmState !== valueToSet) {
 					const oldVal = this.alarmState;
 					this.alarmState = valueToSet;
-					this.emit('PropertyChanged', 'alarmState', this.alarmState, oldVal, AlarmState[this.alarmState]);
+					this.emit('propertyChanged', 'alarmState', this.alarmState, oldVal, AlarmState[this.alarmState]);
 					valueChanged = true;
 				}
 			} else if (updateType === AlarmPanelProperty.AlarmMode) {
 				if (this.alarmMode !== valueToSet) {
 					const oldVal = this.alarmMode;
 					this.alarmMode = valueToSet;
-					this.emit('PropertyChanged', 'alarmMode', this.alarmState, oldVal, AlarmMode[this.alarmMode]);
+					this.emit('propertyChanged', 'alarmMode', this.alarmState, oldVal, AlarmMode[this.alarmMode]);
 					valueChanged = true;
 				}
 			}

package/src/Devices/Elk/ElkAlarmSensorDevice.ts

@@ -1,4 +1,3 @@
-
 import { Family } from '../../Definitions/Global/Families.js';
 import { ISY } from '../../ISY.js';
 import { ISYDeviceNode } from '../ISYDeviceNode.js';
@@ -6,7 +5,7 @@ import { AlarmSensorPhysicalState, AlarmSensorLogicalState } from './ElkAlarmPan
 /////////////////////////////
 // ELKAlarmSensor
 //
-export class ElkAlarmSensorDevice extends ISYDeviceNode<Family.Global,any,any> {
+export class ElkAlarmSensorDevice extends ISYDeviceNode<Family.Global, any, any> {
 	[x: string]: any;
 	public area: number;
 	public zone: string;
@@ -17,9 +16,12 @@ export class ElkAlarmSensorDevice extends ISYDeviceNode<Family.Global,any,any> {
 	public physicalState: AlarmSensorPhysicalState;
 	public logicalState: AlarmSensorLogicalState;
 	public voltage: number;
-	constructor (isy: ISY, name: string, area: number, zone: string) {
+	constructor(isy: ISY, name: string, area: number, zone: string) {
 		super(isy, {
-			family: Family.Global, name, address: `ElkZone_${zone}`, enabled: true,
+			family: Family.Global,
+			name,
+			address: `ElkZone_${zone}`,
+			enabled: true,
 			pnode: undefined,
 			startDelay: 0,
 			hint: '',
@@ -49,13 +51,13 @@ export class ElkAlarmSensorDevice extends ISYDeviceNode<Family.Global,any,any> {
 		return this.physicalState;
 	}
 	public isBypassed() {
-		return (this.logicalState === 3);
+		return this.logicalState === 3;
 	}
 	public getLogicalState() {
 		return this.logicalState;
 	}
 	public getCurrentDoorWindowState() {
-		return (this.physicalState === this.SENSOR_STATE_PHYSICAL_OPEN || this.logicalState === this.SENSOR_STATE_LOGICAL_VIOLATED);
+		return this.physicalState === this.SENSOR_STATE_PHYSICAL_OPEN || this.logicalState === this.SENSOR_STATE_LOGICAL_VIOLATED;
 	}
 	public getSensorStatus() {
 		return 'PS [' + this.physicalState + '] LS [' + this.logicatState + ']';
@@ -63,17 +65,11 @@ export class ElkAlarmSensorDevice extends ISYDeviceNode<Family.Global,any,any> {
 	public isPresent() {
 		if (this.voltage < 65 || this.voltage > 80) {
 			return true;
-		}
-		else {
+		} else {
 			return false;
 		}
 	}
-	public override handleEvent(event: {
-		control?: string;
-		data?: any;
-		node?: any;
-		eventInfo?: any;
-	}) {
+	public override handleEvent(event: { control?: string; data?: any; node?: any; eventInfo?: any }) {
 		const zoneUpdate = event.eventInfo.ze;
 		const zone = zoneUpdate.attr.zone;
 		const updateType = zoneUpdate.attr.type;
@@ -84,24 +80,22 @@ export class ElkAlarmSensorDevice extends ISYDeviceNode<Family.Global,any,any> {
 				if (this.logicalState !== valueToSet) {
 					const temp = this.logicalState;
 					this.logicalState = valueToSet;
-					this.emit('PropertyChanged', 'logicalState', this.logicalState, temp, this.voltage.toString());
+					this.emit('propertyChanged', 'logicalState', this.logicalState, temp, this.voltage.toString());
 					// Not triggering change update on logical state because physical always follows and don't want double notify.
 					// valueChanged = true;
 				}
-			}
-			else if (updateType === 52) {
+			} else if (updateType === 52) {
 				if (this.physicalState !== valueToSet) {
 					const temp = this.physicalState;
 					this.physicalState = valueToSet;
-					this.emit('PropertyChanged', 'physicalState', this.physicalState, temp, this.voltage.toString());
+					this.emit('propertyChanged', 'physicalState', this.physicalState, temp, this.voltage.toString());
 					valueChanged = true;
 				}
-			}
-			else if (updateType === 53) {
+			} else if (updateType === 53) {
 				if (this.voltage !== valueToSet) {
 					const temp = this.voltage;
 					this.voltage = valueToSet;
-					this.emit('PropertyChanged', 'voltage', this.voltage, temp, this.voltage.toString());
+					this.emit('propertyChanged', 'voltage', this.voltage, temp, this.voltage.toString());
 					valueChanged = true;
 				}
 			}

package/src/Devices/Insteon/Generated/RelayLamp.ts

@@ -1,5 +1,5 @@
-/* THIS FILE WAS AUTOMATICALLY GENERATED. DO NOT EDIT DIRECTLY. */
-
+/* 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";
@@ -11,12 +11,12 @@ 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 = "RelayLampOnly";
-
+
 type Commands = RelayLamp.Commands;
 type Drivers = RelayLamp.Drivers;
-
+
 export class RelayLampNode extends Base<Drivers, Commands> implements RelayLamp.Interface {
 	public readonly commands = {
 		DON: this.on,
@@ -33,6 +33,7 @@ export class RelayLampNode extends Base<Drivers, Commands> implements RelayLamp.
 		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 });
@@ -62,9 +63,9 @@ export class RelayLampNode extends Base<Drivers, Commands> implements RelayLamp.
 		return this.drivers.ERR?.value;
 	}
 }
-
+
 NodeFactory.register(RelayLampNode);
-
+
 export namespace RelayLamp {
 	export interface Interface extends Omit<InstanceType<typeof RelayLampNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "RelayLampOnly";

package/src/Devices/Insteon/InsteonBaseDevice.ts

@@ -1,16 +1,17 @@
+import 'winston';
+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';
-import { ISY } from '../../ISY.js';
 import { UnitOfMeasure as UOM, UnitOfMeasure } from '../../Definitions/Global/UOM.js';
-import { byteToDegree, byteToPct, pctToByte, type StringKeys } from '../../Utils.js';
+import { ISY } from '../../ISY.js';
+import { ISYNode } from '../../ISYNode.js';
 import { NodeInfo } from '../../Model/NodeInfo.js';
+import { byteToDegree, byteToPct, pctToByte, type StringKeys } from '../../Utils.js';
 import { ISYDeviceNode } from '../ISYDeviceNode.js';
-import { ISYNode } from '../../ISYNode.js';
-import 'winston';
-import type { Driver, DriverType } from '../../Definitions/Global/Drivers.js';
-import { Converters } from '../../Converters.js';
-import type { Command } from '../../Definitions/Global/Commands.js';
 
 import type { Merge } from '@project-chip/matter.js/util';
+import type { DriverState } from '../../Model/DriverState.js';
 
 // import { InsteonNLS } from './insteonfam.js'
 export class InsteonBaseDevice<D extends ISYNode.DriverSignatures = {}, C extends ISYNode.CommandSignatures = {}> extends ISYDeviceNode<
@@ -23,7 +24,7 @@ export class InsteonBaseDevice<D extends ISYNode.DriverSignatures = {}, C extend
 	constructor(isy: ISY, deviceNode: NodeInfo) {
 		super(isy, deviceNode);
 		this.family = Family.Insteon;
-
+		(this.drivers as any).ERR = Driver.create('ERR', this as any, deviceNode.property as DriverState, { uom: UnitOfMeasure.Index, label: 'Responding', name: 'responding' });
 		//// this.productName = InsteonNLS.getDeviceDescription(String.fromCharCode(category,device,version));
 		//his.childDevices = {};
 	}
@@ -37,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

@@ -5,12 +5,15 @@ import { States } from '../../ISYConstants.js';
 import { InsteonBaseDevice } from './InsteonBaseDevice.js';
 import { InsteonDimmableDevice } from './InsteonDimmableDevice.js';
 import 'winston';
-import type { NodeInfo } from '../../Model/NodeInfo.js';
-import {Insteon} from './index.js';
+import type { NodeInfo, StaticNodeInfo } from '../../Model/NodeInfo.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 {
-	constructor (isy: ISY, deviceNode: NodeInfo) {
+export class InsteonFanMotorDevice extends InsteonBaseDevice<Driver.Signatures<'ST'>, Command.Signatures<'DON' | 'DOF'>> {
+	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;
 	}
 
@@ -22,7 +25,7 @@ export class InsteonFanMotorDevice extends InsteonBaseDevice {
 	}
 
 	public async updateFanSpeed(level: number) {
-		return (level);
+		return level;
 	}
 	public async updateIsOn(isOn: boolean) {
 		if (!isOn) {
@@ -31,7 +34,6 @@ export class InsteonFanMotorDevice extends InsteonBaseDevice {
 			//return this.commands.BEEP(States.Level.Max);
 		}
 	}
-
 }
 
 export class InsteonFanDevice extends InsteonBaseDevice {
@@ -40,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) {
@@ -58,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;
 			}