isy-nodejs 1.0.6-alpha.2 → 1.0.8-alpha.0

package/src/Devices/ZigBeeLegacy/Generated/Relay.ts

@@ -17,7 +17,7 @@ const nodeDefId = "RelayLoadControl";
 type Commands = Relay.Commands;
 type Drivers = Relay.Drivers;
 
-export class RelayNode extends Base<Drivers, Commands> implements Relay.Interface {
+class RelayNode extends Base<Drivers, Commands> implements Relay.Interface {
 	public override readonly commands = {
 		DON: this.on,
 		DOF: this.off,
@@ -25,36 +25,38 @@ export class RelayNode extends Base<Drivers, Commands> implements Relay.Interfac
 		ADRPST: this.adr
 	};
 	static override nodeDefId = "RelayLoadControl";
-	static override implements = ["RelayLoadControl"];
-	declare readonly nodeDefId: "RelayLoadControl";
+	static override implements = ['RelayLoadControl'];
+	declare readonly nodeDefId: 'RelayLoadControl';
 	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" });
+		this.drivers.ST = Driver.create("ST", this, nodeInfo.state['ST'], { uom: UnitOfMeasure.Unknown, label: "Status", name: "status" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Unknown, label: "Responding", name: "responding" });
 	}
 	async on() { return this.sendCommand("DON"); }
 	async off() { return this.sendCommand("DOF"); }
 	async query() { return this.sendCommand("QUERY"); }
-	async adr(value: (0 | 1)) { return this.sendCommand("ADRPST", value); }
-	public get status(): (0 | 100) {
-		return this.drivers.ST?.value;
-	}
-	public get responding(): ZigBeeLegacy.Error {
-		return this.drivers.ERR?.value;
-	}
+	async adr(value: ) { return this.sendCommand("ADRPST", value); }
+	public get status(): {
+        
+return this.drivers.ST?.value;
+    }
+    public 
+get responding(): 
+{
+	return this.drivers.ERR?.value;
+}
 }
 
 NodeFactory.register(RelayNode);
 
 export namespace Relay {
 	export interface Interface extends Omit<InstanceType<typeof RelayNode>, keyof ISYDeviceNode<any, any, any, any>> {
-		nodeDefId: "RelayLoadControl";
 	}
 	export function is(node: ISYNode<any, any, any, any>): node is RelayNode {
-		return ["RelayLoadControl"].includes(node.nodeDefId);
+		return ['RelayLoadControl'].includes(node.nodeDefId);
 	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is RelayNode {
-		return ["RelayLoadControl"].includes(node.nodeDefId);
+		return ['RelayLoadControl'].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new RelayNode(isy, nodeInfo);
@@ -73,21 +75,21 @@ export namespace Relay {
 			label: "Query";
 			name: "query";
 		};
-		ADRPST: ((value: (0 | 1)) => Promise<boolean>) & {
+		ADRPST: ((value: ) => Promise<boolean>) & {
 			label: "ADR";
 			name: "adr";
 		};
 	};
 	export type Drivers = {
 		ST: {
-			uom: UnitOfMeasure.Percent;
-			value: (0 | 100);
+			uom: ;
+			value: ;
 			label: "Status";
 			name: "status";
 		};
 		ERR: {
-			uom: UnitOfMeasure.Index;
-			value: ZigBeeLegacy.Error;
+			uom: ;
+			value: ;
 			label: "Responding";
 			name: "responding";
 		};

package/src/Devices/ZigBeeLegacy/Generated/Thermostat.ts

@@ -17,7 +17,7 @@ const nodeDefId = "Thermostat";
 type Commands = Thermostat.Commands;
 type Drivers = Thermostat.Drivers;
 
-export class ThermostatNode extends Base<Drivers, Commands> implements Thermostat.Interface {
+class ThermostatNode extends Base<Drivers, Commands> implements Thermostat.Interface {
 	public override readonly commands = {
 		CLISPH: this.updateHeatSetpoint,
 		CLISPC: this.updateCoolSetpoint,
@@ -30,100 +30,116 @@ export class ThermostatNode extends Base<Drivers, Commands> implements Thermosta
 		ADRPST: this.adr
 	};
 	static override nodeDefId = "Thermostat";
-	static override implements = ["Thermostat"];
-	declare readonly nodeDefId: "Thermostat";
+	static override implements = ['Thermostat'];
+	declare readonly nodeDefId: 'Thermostat';
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Degree, label: "Temperature", name: "temperature" });
-		this.drivers.CLISPH = Driver.create("CLISPH", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Degree, label: "Heat Setpoint", name: "heatSetpoint" });
-		this.drivers.CLISPC = Driver.create("CLISPC", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Degree, label: "Cool Setpoint", name: "coolSetpoint" });
-		this.drivers.CLIMD = Driver.create("CLIMD", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.ThermostatMode, label: "Mode", name: "mode" });
-		this.drivers.CLIFS = Driver.create("CLIFS", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.ThermostatFanMode, label: "Fan Mode", name: "fanMode" });
-		this.drivers.CLIHCS = Driver.create("CLIHCS", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.ThermostatHeatCoolState, label: "Heat/Cool State", name: "heatCoolState" });
-		this.drivers.CLIFRS = Driver.create("CLIFRS", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.ThermostatFanRunState, label: "Fan State", name: "fanState" });
-		this.drivers.CLISMD = Driver.create("CLISMD", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Schedule Mode", name: "scheduleMode" });
-		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
+		this.drivers.ST = Driver.create("ST", this, nodeInfo.state['ST'], { uom: UnitOfMeasure.Unknown, label: "Temperature", name: "temperature" });
+		this.drivers.CLISPH = Driver.create("CLISPH", this, nodeInfo.state['CLISPH'], { uom: UnitOfMeasure.Unknown, label: "Heat Setpoint", name: "heatSetpoint" });
+		this.drivers.CLISPC = Driver.create("CLISPC", this, nodeInfo.state['CLISPC'], { uom: UnitOfMeasure.Unknown, label: "Cool Setpoint", name: "coolSetpoint" });
+		this.drivers.CLIMD = Driver.create("CLIMD", this, nodeInfo.state['CLIMD'], { uom: UnitOfMeasure.Unknown, label: "Mode", name: "mode" });
+		this.drivers.CLIFS = Driver.create("CLIFS", this, nodeInfo.state['CLIFS'], { uom: UnitOfMeasure.Unknown, label: "Fan Mode", name: "fanMode" });
+		this.drivers.CLIHCS = Driver.create("CLIHCS", this, nodeInfo.state['CLIHCS'], { uom: UnitOfMeasure.Unknown, label: "Heat/Cool State", name: "heatCoolState" });
+		this.drivers.CLIFRS = Driver.create("CLIFRS", this, nodeInfo.state['CLIFRS'], { uom: UnitOfMeasure.Unknown, label: "Fan State", name: "fanState" });
+		this.drivers.CLISMD = Driver.create("CLISMD", this, nodeInfo.state['CLISMD'], { uom: UnitOfMeasure.Unknown, label: "Schedule Mode", name: "scheduleMode" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Unknown, label: "Responding", name: "responding" });
 	}
-	async updateHeatSetpoint(value: number) { return this.sendCommand("CLISPH", value); }
-	async updateCoolSetpoint(value: number) { return this.sendCommand("CLISPC", value); }
-	async updateMode(value: number) { return this.sendCommand("CLIMD", value); }
-	async updateFanMode(value: (0 | 1)) { return this.sendCommand("CLIFS", value); }
-	async updateScheduleMode(value: number) { return this.sendCommand("CLISMD", value); }
-	async heatSetpointShift(value: number) { return this.sendCommand("CLISPHD", value); }
-	async coolSetpointShift(value: number) { return this.sendCommand("CLISPCD", value); }
+	async updateHeatSetpoint(value: ) { return this.sendCommand("CLISPH", value); }
+	async updateCoolSetpoint(value: ) { return this.sendCommand("CLISPC", value); }
+	async updateMode(value: ) { return this.sendCommand("CLIMD", value); }
+	async updateFanMode(value: ) { return this.sendCommand("CLIFS", value); }
+	async updateScheduleMode(value: ) { return this.sendCommand("CLISMD", value); }
+	async heatSetpointShift(value: ) { return this.sendCommand("CLISPHD", value); }
+	async coolSetpointShift(value: ) { return this.sendCommand("CLISPCD", value); }
 	async query() { return this.sendCommand("QUERY"); }
-	async adr(value: (0 | 1)) { return this.sendCommand("ADRPST", value); }
-	public get temperature(): number {
-		return this.drivers.ST?.value;
-	}
-	public get heatSetpoint(): number {
-		return this.drivers.CLISPH?.value;
-	}
-	public get coolSetpoint(): number {
-		return this.drivers.CLISPC?.value;
-	}
-	public get mode(): number {
-		return this.drivers.CLIMD?.value;
-	}
-	public get fanMode(): (0 | 1) {
-		return this.drivers.CLIFS?.value;
-	}
-	public get heatCoolState(): number {
-		return this.drivers.CLIHCS?.value;
-	}
-	public get fanState(): (0 | 1) {
-		return this.drivers.CLIFRS?.value;
-	}
-	public get scheduleMode(): number {
-		return this.drivers.CLISMD?.value;
-	}
-	public get responding(): ZigBeeLegacy.Error {
-		return this.drivers.ERR?.value;
-	}
+	async adr(value: ) { return this.sendCommand("ADRPST", value); }
+	public get temperature(): {
+        
+return this.drivers.ST?.value;
+    }
+    public 
+get heatSetpoint(): 
+{
+	return this.drivers.CLISPH?.value;
+}
+    public 
+get coolSetpoint(): 
+{
+	return this.drivers.CLISPC?.value;
+}
+    public 
+get mode(): 
+{
+	return this.drivers.CLIMD?.value;
+}
+    public 
+get fanMode(): 
+{
+	return this.drivers.CLIFS?.value;
+}
+    public 
+get heatCoolState(): 
+{
+	return this.drivers.CLIHCS?.value;
+}
+    public 
+get fanState(): 
+{
+	return this.drivers.CLIFRS?.value;
+}
+    public 
+get scheduleMode(): 
+{
+	return this.drivers.CLISMD?.value;
+}
+    public 
+get responding(): 
+{
+	return this.drivers.ERR?.value;
+}
 }
 
 NodeFactory.register(ThermostatNode);
 
 export namespace Thermostat {
 	export interface Interface extends Omit<InstanceType<typeof ThermostatNode>, keyof ISYDeviceNode<any, any, any, any>> {
-		nodeDefId: "Thermostat";
 	}
 	export function is(node: ISYNode<any, any, any, any>): node is ThermostatNode {
-		return ["Thermostat"].includes(node.nodeDefId);
+		return ['Thermostat'].includes(node.nodeDefId);
 	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is ThermostatNode {
-		return ["Thermostat"].includes(node.nodeDefId);
+		return ['Thermostat'].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new ThermostatNode(isy, nodeInfo);
 	}
 	export const Node = ThermostatNode;
 	export type Commands = {
-		CLISPH: ((value: number) => Promise<boolean>) & {
+		CLISPH: ((value: ) => Promise<boolean>) & {
 			label: "Heat Setpoint";
 			name: "updateHeatSetpoint";
 		};
-		CLISPC: ((value: number) => Promise<boolean>) & {
+		CLISPC: ((value: ) => Promise<boolean>) & {
 			label: "Cool Setpoint";
 			name: "updateCoolSetpoint";
 		};
-		CLIMD: ((value: number) => Promise<boolean>) & {
+		CLIMD: ((value: ) => Promise<boolean>) & {
 			label: "Mode";
 			name: "updateMode";
 		};
-		CLIFS: ((value: (0 | 1)) => Promise<boolean>) & {
+		CLIFS: ((value: ) => Promise<boolean>) & {
 			label: "Fan Mode";
 			name: "updateFanMode";
 		};
-		CLISMD: ((value: number) => Promise<boolean>) & {
+		CLISMD: ((value: ) => Promise<boolean>) & {
 			label: "Schedule Mode";
 			name: "updateScheduleMode";
 		};
-		CLISPHD: ((value: number) => Promise<boolean>) & {
+		CLISPHD: ((value: ) => Promise<boolean>) & {
 			label: "Heat Setpoint Shift";
 			name: "heatSetpointShift";
 		};
-		CLISPCD: ((value: number) => Promise<boolean>) & {
+		CLISPCD: ((value: ) => Promise<boolean>) & {
 			label: "Cool Setpoint Shift";
 			name: "coolSetpointShift";
 		};
@@ -131,63 +147,63 @@ export namespace Thermostat {
 			label: "Query";
 			name: "query";
 		};
-		ADRPST: ((value: (0 | 1)) => Promise<boolean>) & {
+		ADRPST: ((value: ) => Promise<boolean>) & {
 			label: "ADR";
 			name: "adr";
 		};
 	};
 	export type Drivers = {
 		ST: {
-			uom: UnitOfMeasure.Degree;
-			value: number;
+			uom: ;
+			value: ;
 			label: "Temperature";
 			name: "temperature";
 		};
 		CLISPH: {
-			uom: UnitOfMeasure.Degree;
-			value: number;
+			uom: ;
+			value: ;
 			label: "Heat Setpoint";
 			name: "heatSetpoint";
 		};
 		CLISPC: {
-			uom: UnitOfMeasure.Degree;
-			value: number;
+			uom: ;
+			value: ;
 			label: "Cool Setpoint";
 			name: "coolSetpoint";
 		};
 		CLIMD: {
-			uom: UnitOfMeasure.ThermostatMode;
-			value: number;
+			uom: ;
+			value: ;
 			label: "Mode";
 			name: "mode";
 		};
 		CLIFS: {
-			uom: UnitOfMeasure.ThermostatFanMode;
-			value: (0 | 1);
+			uom: ;
+			value: ;
 			label: "Fan Mode";
 			name: "fanMode";
 		};
 		CLIHCS: {
-			uom: UnitOfMeasure.ThermostatHeatCoolState;
-			value: number;
+			uom: ;
+			value: ;
 			label: "Heat/Cool State";
 			name: "heatCoolState";
 		};
 		CLIFRS: {
-			uom: UnitOfMeasure.ThermostatFanRunState;
-			value: (0 | 1);
+			uom: ;
+			value: ;
 			label: "Fan State";
 			name: "fanState";
 		};
 		CLISMD: {
-			uom: UnitOfMeasure.Index;
-			value: number;
+			uom: ;
+			value: ;
 			label: "Schedule Mode";
 			name: "scheduleMode";
 		};
 		ERR: {
-			uom: UnitOfMeasure.Index;
-			value: ZigBeeLegacy.Error;
+			uom: ;
+			value: ;
 			label: "Responding";
 			name: "responding";
 		};

package/src/ISY.ts

@@ -28,6 +28,7 @@ import { ISYError } from './ISYError.js';
 import type { Config } from './Model/Config.js';
 import { findPackageJson } from './Utils.js';
 import { GenericNode } from './Devices/GenericNode.js';
+import { CompositeDevice } from './Devices/CompositeDevice.js';
 
 type InitStep = 'config' | 'loadNodes' | 'readFolders' | 'readDevices' | 'readScenes' | 'variables' | 'websocket' | 'refreshStatuses' | 'initialize';
 
@@ -753,7 +754,7 @@ export class ISY extends EventEmitter implements Disposable {
 					} else {
 						this.deviceMap[nodeInfo.pnode].push(nodeInfo.address);
 					}
-					let newDevice: ISYDeviceNode<any, any, any, any> = null;
+					let newDevice = null;
 
 					// let deviceTypeInfo = this.isyTypeToTypeName(device.type, device.address);
 					// this.logger.info(JSON.stringify(deviceTypeInfo));
@@ -761,7 +762,7 @@ export class ISY extends EventEmitter implements Disposable {
 					const enabled = nodeInfo.enabled ?? true;
 					const d = await NodeFactory.get(nodeInfo);
 					const m = DeviceFactory.getDeviceDetails(nodeInfo);
-					const cls = m?.class ?? d;
+					const cls = m.class ?? d;
 					nodeInfo.property = Array.isArray(nodeInfo.property) ? nodeInfo.property : [nodeInfo.property];
 					nodeInfo.state = nodeInfo.property.reduce((acc, p) => {
 						if (p && p?.id) {
@@ -773,7 +774,8 @@ export class ISY extends EventEmitter implements Disposable {
 
 					if (cls) {
 						try {
-							newDevice = new cls(this, nodeInfo) as ISYDeviceNode<any, any, any, any>;
+							newDevice = new cls(this, nodeInfo);
+
 						} catch (e) {
 							this.logger.error(`Error creating device ${nodeInfo.name} with type ${nodeInfo.type} and nodedef ${nodeInfo.nodeDefId}: ${e.message}`);
 							continue;
@@ -808,7 +810,12 @@ export class ISY extends EventEmitter implements Disposable {
 							// this.deviceList.push(newDevice);
 						} else {
 						}
-						this.nodeMap.set(newDevice.address, newDevice);
+						this.nodeMap.set(newDevice.address, CompositeDevice.isComposite(newDevice) ? newDevice.root : newDevice);
+						if(CompositeDevice.isComposite(newDevice))
+						{
+							if(this.deviceList.set)
+								this.deviceList.set(newDevice.address, newDevice);
+						}
 					} else {
 						this.logger.info(`Ignoring disabled device: ${nodeInfo.name}`);
 					}
@@ -816,7 +823,22 @@ export class ISY extends EventEmitter implements Disposable {
 					this.logger.error(`Error loading device node: ${e.message}`);
 				}
 			}
-			this.logger.info(`${this.nodeMap.size} devices added.`);
+			this.logger.info(`${this.nodeMap.size} nodes added.`);
+			for(const node of this.nodeMap.values()) {
+				if(node.parentAddress !== node.address) {
+					let parent = this.deviceList.get(node.parentAddress) as unknown as CompositeDevice<any,any>;
+					if(parent && CompositeDevice.isComposite(parent))
+						parent.addNode(node);
+
+				}
+				else
+				{
+					this.deviceList.set(node.address, node as unknown as ISYDevice<any, any, any, any>);
+				}
+
+
+			}
+			this.logger.info(`${this.deviceList.size} unique devices added.`);
 		} catch (e) {
 			throw new ISYInitializationError(e, 'readDevices');
 		}

package/src/ISYDevice.ts

@@ -5,14 +5,14 @@ import { ISYDeviceNode } from './Devices/ISYDeviceNode.js';
 import type { ISYNode } from './ISYNode.js';
 import type { ISYScene } from './ISYScene.js';
 
-export interface ISYDevice<T extends Family, D extends ISYNode.DriverSignatures, C extends ISYNode.CommandSignatures, E extends ISYNode.EventSignatures> extends ISYDeviceInfo {
+export interface ISYDevice<T extends Family, D, C, E> extends ISYDeviceInfo {
 	// #region Properties (22)
 
 	address: string;
 	category: Category;
-	commands: Command.ForAll<C>;
+	commands: C;
 	deviceClass: any;
-	drivers: Driver.ForAll<D>;
+	drivers: D;
 
 	events: E;
 	enabled: boolean;
@@ -52,6 +52,7 @@ export function isDeviceClass<T extends Family, D extends ISYNode.DriverSignatur
 	return device.prototype instanceof ISYDeviceNode;
 }
 
+
 export interface ISYDeviceInfo {
 	type: string;
 	deviceClass: any;

package/src/ISYNode.ts

@@ -4,18 +4,22 @@ import { Family } from './Definitions/Global/Families.js';
 import { UnitOfMeasure } from './Definitions/Global/UOM.js';
 import { ISY } from './ISY.js';
 
+import type { Merge, UnionToIntersection } from '@matter/general';
 import { CliConfigSetLevels } from 'winston/lib/winston/config/index.js';
 import { Converter } from './Converters.js';
 import type { Command } from './Definitions/Global/Commands.js';
 import { Event } from './Definitions/Global/Events.js';
+import type { CompositeDevice } from './Devices/CompositeDevice.js';
 import type { Constructor } from './Devices/Constructor.js';
+
+
+import { NodeType } from './ISYConstants.js';
+import type { ISYScene } from './ISYScene.js';
 import type { DriverState } from './Model/DriverState.js';
 import { NodeInfo } from './Model/NodeInfo.js';
 import type { NodeNotes } from './Model/NodeNotes.js';
 import { type ObjectToUnion, type StringKeys } from './Utils.js';
-import { NodeType } from './ISYConstants.js';
-import type { ISYScene } from './ISYScene.js';
-import type { Merge, UnionToIntersection } from '@matter/general';
+import type { ISYDevice } from './ISYDevice.js';
 
 //type DriverValues<DK extends string | number | symbol,V = any> = {[x in DK]?:V};
 
@@ -24,7 +28,7 @@ export class ISYNode<
 	D extends ISYNode.DriverSignatures = {},
 	C extends ISYNode.CommandSignatures = {},
 	E extends ISYNode.EventSignatures = { [x in keyof D]: Event.DriverToEvent<D[x]> & { driver: x } } & { [x in keyof C]: Event.CommandToEvent<C[x]> & { command: x } }
-> {
+>  {
 	// #region Properties (32)
 
 	static #displayNameFunction: Function;
@@ -157,18 +161,17 @@ export class ISYNode<
 
 	public applyStatus(prop: DriverState) {
 		try {
-		var d = this.drivers[prop.id];
+			var d = this.drivers[prop.id];
 
-		if (d) {
-			d.apply(prop);
+			if (d) {
+				d.apply(prop);
 
-			this.logger(`Property ${d?.label ?? prop.id} (${prop.id}) refreshed to: ${d.value} (${prop.formatted}})`);
-			//d.state.value = this.convertFrom(prop.value, prop.uom, prop.id);
-			//d.state.formatted = prop.formatted;
-			//d.state.uom = prop.uom;
-		}
-		}
-		catch(e) {
+				this.logger(`Property ${d?.label ?? prop.id} (${prop.id}) refreshed to: ${d.value} (${prop.formatted}})`);
+				//d.state.value = this.convertFrom(prop.value, prop.uom, prop.id);
+				//d.state.formatted = prop.formatted;
+				//d.state.uom = prop.uom;
+			}
+		} catch (e) {
 			this.logger(e?.message ?? e, 'error');
 		}
 	}
@@ -270,9 +273,9 @@ export class ISYNode<
 			const e = event.control;
 			const dispName = this.commands[e]?.name;
 			if (dispName !== undefined && dispName !== null) {
-				this.logger(`Command ${dispName} (${e}) event sent.`);
+				this.logger(`Command ${dispName} (${e}) event received.`);
 			} else {
-				this.logger(`Command ${e} event sent.`);
+				this.logger(`Command ${e} event received.`);
 			}
 			this.handleControlTrigger(e);
 			return true;
@@ -282,11 +285,12 @@ export class ISYNode<
 	public handlePropertyChange(propertyName: StringKeys<D>, value: any, uom: UnitOfMeasure, prec?: number, formattedValue?: string): boolean {
 		this.lastChanged = new Date();
 		let driver = this.drivers[propertyName];
-		this.logger(`Driver ${propertyName} (${driver?.label} value update ${value} (${formattedValue}) uom: ${UnitOfMeasure[uom]} event received.`);
-		const oldValue = driver?.value;
+		/*this.logger(`Driver ${propertyName} (${driver?.label} value update ${value} (${formattedValue}) uom: ${UnitOfMeasure[uom]} event received.`);*/
+		const oldValue = driver?.state.value;
+		const oldValueRaw = driver?.state.rawValue;
 		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.logger(`Driver ${driver.label} updated from ${oldValue} (${oldValueRaw}) to ${driver.state.value} (${driver.state.rawValue})`);
+			//this.emit('propertyChanged', propertyName, value, oldValue, formattedValue);
 			this.scenes?.forEach((element) => {
 				this.logger(`Recalulating ${element.deviceFriendlyName}`);
 				element.recalculateState();
@@ -359,23 +363,24 @@ export class ISYNode<
 	public async sendCommand(command: StringKeys<C>, value: string | number, parameters: Record<string | symbol, string | number | undefined>);
 	public async sendCommand(command: StringKeys<C>, value: string | number): Promise<any>;
 	public async sendCommand(command: StringKeys<C>, parameters: Record<string | symbol, string | number | undefined>): Promise<any>;
-	async sendCommand(command: StringKeys<C>, valueOrParameters?: string | number | Record<string | symbol, string | number | undefined>, parameters?: Record<string | symbol, string | number | undefined>): Promise<any> {
+	async sendCommand(
+		command: StringKeys<C>,
+		valueOrParameters?: string | number | Record<string | symbol, string | number | undefined>,
+		parameters?: Record<string | symbol, string | number | undefined>
+	): Promise<any> {
 		if (valueOrParameters === null || valueOrParameters === undefined) {
 			return this.isy.sendNodeCommand(this, command);
 		}
 
-			if(parameters === null || parameters === undefined) {
-				return this.isy.sendNodeCommand(this, command, valueOrParameters);
-			}
-			if(typeof valueOrParameters === 'object') {
-				return this.isy.sendNodeCommand(this, command, {...valueOrParameters,...parameters});
-			}
-			if(typeof valueOrParameters === 'string' || typeof valueOrParameters === 'number') {
-				return this.isy.sendNodeCommand(this, command, { default: valueOrParameters, ...parameters });
-			}
-
-
-
+		if (parameters === null || parameters === undefined) {
+			return this.isy.sendNodeCommand(this, command, valueOrParameters);
+		}
+		if (typeof valueOrParameters === 'object') {
+			return this.isy.sendNodeCommand(this, command, { ...valueOrParameters, ...parameters });
+		}
+		if (typeof valueOrParameters === 'string' || typeof valueOrParameters === 'number') {
+			return this.isy.sendNodeCommand(this, command, { default: valueOrParameters, ...parameters });
+		}
 	}
 
 	public async updateProperty(propertyName: string, value: any): Promise<any> {
@@ -539,12 +544,17 @@ export type EventsOf<T> = T extends ISYNode<any, any, any, infer E> ? E : never;
 export namespace ISYNode {
 	export type FromSignatures<T> = T extends DriverSignatures ? Driver.ForAll<T> : never;
 
-	export type DriversOf<T> = T extends ISYNode<any, infer D, any, any> ? D : never;
+	type InternalDriversOf<T> = T extends ISYNode<any, infer D, any, any> ? D : never;
+
+	export type DriversOf<T> =
+		T extends ISYNode<any, any, any, any> ? InternalDriversOf<T>
+		: T extends CompositeDevice<any, any> ? T['drivers']
+		: never;
 	export type CommandsOf<T> = T extends ISYNode<any, any, infer C, any> ? C : never;
 	export type EventsOf<T> = T extends ISYNode<any, any, any, infer E> ? E : never;
 	export type FamilyOf<T> = T extends ISYNode<infer F, any, any, any> ? F : never;
 
-	export type DriverTypesOf<T extends ISYNode> = ObjectToUnion<DriversOf<T>>;
+	export type DriverTypesOf<T> = ObjectToUnion<DriversOf<T>>;
 
 	export type CommandTypesOf<T extends ISYNode> = ObjectToUnion<CommandsOf<T>>;
 
@@ -552,9 +562,16 @@ export namespace ISYNode {
 
 	export type EventNamesOf<T extends ISYNode> = EventTypesOf<T> extends { name: infer U } ? U : never;
 
-	export type DriverNamesOf<T extends ISYNode> = DriverTypesOf<T> extends { name: infer U } ? U : never;
+	export type DriverNamesOf<T> =
+		DriverTypesOf<T> extends { name: infer U } ? U
+		: DriversOf<T> extends { name: infer U } ? U
+		: never;
+
+	export type DriverKeysOf<T> = keyof DriversOf<T>;
+
+	export type CommandKeysOf<T> = keyof CommandsOf<T>;
 
-	export type CommandNamesOf<T extends ISYNode> = CommandTypesOf<T> extends { name: infer U } ? U : never;
+	export type CommandNamesOf<T extends ISYNode> = CommandsOf<T> extends { name: infer U } ? U : never;
 	export type List = NodeList;
 
 	export type DriverMap<T extends NodeList> = Flatten<{
@@ -584,7 +601,7 @@ export namespace ISYNode {
 
 	export const With = <K extends Family, D extends DriverSignatures, C extends CommandSignatures, T extends Constructor<ISYNode<K, any, any, any>>>(Base: T) => {
 		return class extends Base implements Omit<ISYNode<K, D, C>, 'events'> {
-			declare drivers: Driver.ForAll<any, false>;
+			declare drivers: Driver.ForAll<D, false>;
 			declare commands: Command.ForAll<C>;
 		};
 	};
@@ -592,7 +609,7 @@ export namespace ISYNode {
 	export type WithDrivers<D extends DriverSignatures> =
 		D extends Driver.Signatures<infer U extends keyof D> ?
 			{
-				[K in D[U]['name']]: D[U] extends { name: K } ? D[U]['value'] : unknown;
+				[K in D[U] as K['name']]: K['value'];
 			}
 		:	never;