isy-nodejs 1.0.8-alpha.0 → 1.3.24

package/src/ISYNode.ts

@@ -2,7 +2,7 @@ import { Logger } from 'winston';
 import { Driver } from './Definitions/Global/Drivers.js';
 import { Family } from './Definitions/Global/Families.js';
 import { UnitOfMeasure } from './Definitions/Global/UOM.js';
-import { ISY } from './ISY.js';
+import { type Message, Feature, ISY } from './ISY.js';
 
 import type { Merge, UnionToIntersection } from '@matter/general';
 import { CliConfigSetLevels } from 'winston/lib/winston/config/index.js';
@@ -10,16 +10,17 @@ 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 { NodeFactory } from './Devices/NodeFactory.js';
 import type { DriverState } from './Model/DriverState.js';
 import { NodeInfo } from './Model/NodeInfo.js';
 import type { NodeNotes } from './Model/NodeNotes.js';
+import { NodeType } from './NodeType.js';
+import type { ISYScene } from './Scenes/ISYScene.js';
+import type { Factory as BaseFactory, MaybeWithUOM } from './Utils.js';
 import { type ObjectToUnion, type StringKeys } from './Utils.js';
-import type { ISYDevice } from './ISYDevice.js';
+import type { Jsonify } from 'type-fest';
+import type { JsonifyObject } from 'type-fest/source/jsonify.js';
+import type { EventEmitter } from 'stream';
 
 //type DriverValues<DK extends string | number | symbol,V = any> = {[x in DK]?:V};
 
@@ -27,8 +28,8 @@ export class ISYNode<
 	T extends Family = Family,
 	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 } }
->  {
+	E extends ISYNode.EventSignatures = {},
+> {
 	// #region Properties (32)
 
 	static #displayNameFunction: Function;
@@ -45,8 +46,6 @@ export class ISYNode<
 	public static nodeDefId = 'Unknown';
 
 	public static implements: string[] = [];
-
-	public baseName: any;
 	public commands: Command.ForAll<C>;
 	//public readonly formatted: DriverValues<keyof D,string> = {};
 	//public readonly uom: { [x in Driver.Literal]?: UnitOfMeasure } = { ST: UnitOfMeasure.Boolean };
@@ -55,7 +54,7 @@ export class ISYNode<
 	public drivers: Driver.ForAll<D> = {} as Driver.ForAll<D>;
 	public enabled: boolean;
 	//TODO: add signature for non-command/non-driver events
-	public events: Merge<Event.NodeEventEmitter<this>, Event.FunctionSigFor<E, Event.NodeEventEmitter<this>>>;
+	public events: Event.EventEmitter<D, E>;
 	//Event.FunctionSigFor<Event.ForAll<E,typeof this>> & Omit<EventEmitter,'on'>
 	/*{
 		[x in E]: x extends keyof D ? {name:`${D[x]["name"]}Changed`, driver: x, value: D[x]["value"], formatted: string, uom: UnitOfMeasure}
@@ -82,12 +81,15 @@ export class ISYNode<
 	public spokenName: string;
 	public type: any;
 
+	public features: Feature;
+
 	// #endregion Properties (32)
 
 	// #region Constructors (1)
 
 	constructor(isy: ISY, node: NodeInfo) {
 		this.isy = isy;
+		this.isy.nodes.set(node.address, this);
 		this.nodeType = 0;
 		this.flag = node.flag;
 		this.nodeDefId = node.nodeDefId;
@@ -120,7 +122,7 @@ export class ISYNode<
 				return isy.logger;
 			};
 
-			this.label = `${this.folder} ${this.baseName}`;
+			this.label = `${this.folder} ${this.baseLabel}`;
 		} else {
 			this.label = this.baseLabel;
 			this.logger = (msg: any, level: keyof CliConfigSetLevels = 'debug', ...meta: any[]) => {
@@ -128,9 +130,8 @@ export class ISYNode<
 				return isy.logger;
 			};
 		}
-		this.events = Event.createEmitter(this);
 
-		//this.logger(this.nodeDefId);
+		this.events = new Event.NodeEventEmitter<this, D, C, E>(this) as Event.EventEmitter<D, E>;
 		this.lastChanged = new Date();
 	}
 
@@ -159,9 +160,18 @@ export class ISYNode<
 		this.scenes.push(isyScene);
 	}
 
+	_initialized: boolean = false;
+	public get initialized(): boolean {
+		if (!this._initialized) {
+			for (const prop in this.drivers) if (this.drivers[prop]?.initialized == false && prop != 'ERR') return false;
+		}
+		this._initialized = true;
+		return true;
+	}
+
 	public applyStatus(prop: DriverState) {
 		try {
-			var d = this.drivers[prop.id];
+			var d = this.drivers?.[prop.id];
 
 			if (d) {
 				d.apply(prop);
@@ -170,6 +180,14 @@ export class ISYNode<
 				//d.state.value = this.convertFrom(prop.value, prop.uom, prop.id);
 				//d.state.formatted = prop.formatted;
 				//d.state.uom = prop.uom;
+			} else {
+				this.logger(`Driver ${prop.id} not found, creating new driver`);
+				//@ts-expect-error
+				this.drivers[prop.id] = Driver.create(prop.id as never, this as any, prop, {
+					uom: prop.uom,
+					label: (prop.name as string) ?? (prop.id as string),
+					name: (prop.name as string) ?? (prop.id as string),
+				});
 			}
 		} catch (e) {
 			this.logger(e?.message ?? e, 'error');
@@ -191,19 +209,30 @@ export class ISYNode<
 
 	public convertFrom(value: any, uom: UnitOfMeasure, propertyName?: StringKeys<D>): any {
 		if (this.drivers[propertyName]?.uom != uom) {
-			this.logger(`Converting ${this.drivers[propertyName].label} to ${UnitOfMeasure[this.drivers[propertyName]?.uom]} from ${UnitOfMeasure[uom]}`);
+			this.logger(
+				`Converting ${this.drivers[propertyName].label} to ${UnitOfMeasure[this.drivers[propertyName]?.uom]} from ${UnitOfMeasure[uom]}`
+			);
 			return this.convert(value, uom, this.drivers[propertyName].uom);
 		}
 	}
 
 	public convertTo(value: any, uom: UnitOfMeasure, propertyName?: StringKeys<D>) {
 		if (this.drivers[propertyName]?.uom != uom) {
-			this.isy.logger.debug(`Converting ${this.drivers[propertyName].label} from ${UnitOfMeasure[this.drivers[propertyName].uom]} to ${UnitOfMeasure[uom]}`);
+			this.isy.logger.debug(
+				`Converting ${this.drivers[propertyName].label} from ${UnitOfMeasure[this.drivers[propertyName].uom]} to ${UnitOfMeasure[uom]}`
+			);
 			return this.convert(value, uom, this.drivers[propertyName].uom);
 		}
 	}
 
-	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);
 	}
@@ -214,13 +243,16 @@ export class ISYNode<
 			// template = template.replace("{", "{this."};
 			const regex = /(?<op1>\w+) \?\? (?<op2>\w+)/g;
 			this.logger(`Display name format: ${template}`);
-			let newttemp = template.replace(regex, "this.$<op1> === null || this.$<op1> === undefined || this.$<op1> === '' ? this.$<op2> : this.$<op1>");
+			let newttemp = template.replace(
+				regex,
+				"this.$<op1> === null || this.$<op1> === undefined || this.$<op1> === '' ? this.$<op2> : this.$<op1>"
+			);
 			this.logger(`Template format updated to: ${newttemp}`);
 			const s = {
 				location: this.location ?? '',
 				folder: this.folder ?? '',
 				spokenName: this.spokenName ?? this.name,
-				name: this.name ?? ''
+				name: this.name ?? '',
 			};
 			newttemp = newttemp.replace('this.name', 'this.baseLabel');
 			ISYNode.#displayNameFunction = new Function(`return \`${newttemp}\`.trim();`);
@@ -233,10 +265,10 @@ export class ISYNode<
 		try {
 			const result = await this.isy.sendRequest(`nodes/${this.address}/notes`, {
 				trailingSlash: false,
-				errorLogLevel: 'debug',
+				errorLogLevel: 'silly',
 				validateStatus(status) {
 					return true;
-				}
+				},
 			});
 			if (result !== null && result !== undefined) {
 				return result.NodeProperties;
@@ -254,24 +286,36 @@ export class ISYNode<
 		return true;
 	}
 
-	public handleEvent(event: { control?: any; data?: any; node?: any; action?: any; fmtAct?: any }): boolean {
-		let actionValue = null;
+	public handleEvent(event: Message<any>): boolean {
+		let actionValue = null,
+			formattedValue = null,
+			uom = null,
+			prec = null;
 		if (event.action instanceof Object) {
 			actionValue = event.action._;
-		} else if (event.action instanceof Number || event.action instanceof String) {
+			uom = event.action.uom;
+			prec = event.action.prec;
+		} else if (typeof event.action == 'number' || typeof event.action == 'string') {
 			actionValue = Number(event.action);
 		}
 
 		if (event.control in this.drivers) {
 			// property not command
-			const formatted = 'fmtAct' in event ? event.fmtAct : actionValue;
-			return this.handlePropertyChange(event.control, actionValue, event.action.uom, event.action.prec, formatted);
+			formattedValue = 'fmtAct' in event ? event.fmtAct : actionValue;
+
+			return this.handlePropertyChange(
+				event.control as StringKeys<D>,
+				actionValue,
+				uom ?? UnitOfMeasure.Unknown,
+				prec,
+				formattedValue
+			);
 		} else if (event.control === '_3') {
-			this.logger(`Received Node Change Event: ${JSON.stringify(event)}. These are currently unsupported.`, 'debug');
+			this.logger(`Received Node Change Event: ${JSON.stringify(event)}.`, 'debug');
 		} 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}) event received.`);
 			} else {
@@ -282,16 +326,20 @@ export class ISYNode<
 		}
 	}
 
-	public handlePropertyChange(propertyName: StringKeys<D>, value: any, uom: UnitOfMeasure, prec?: number, formattedValue?: string): boolean {
+	public handlePropertyChange(
+		propertyName: StringKeys<D>,
+		value: any,
+		uom: UnitOfMeasure,
+		prec?: number,
+		formattedValue?: string
+	): boolean {
 		this.lastChanged = new Date();
-		let driver = this.drivers[propertyName];
+		let driver = this.drivers?.[propertyName];
 		/*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} (${oldValueRaw}) to ${driver.state.value} (${driver.state.rawValue})`);
 			//this.emit('propertyChanged', propertyName, value, oldValue, formattedValue);
-			this.scenes?.forEach((element) => {
+			this.scenes?.forEach(element => {
 				this.logger(`Recalulating ${element.deviceFriendlyName}`);
 				element.recalculateState();
 			});
@@ -333,12 +381,12 @@ export class ISYNode<
 		return result.property;
 	}
 
-	public async refresh(): Promise<any> {
+	public async refreshState(): Promise<any> {
 		const device = this;
 		const node = (await this.isy.sendRequest(`nodes/${this.address}/status`)).node;
 		// this.logger(node);
 		this.parseResult(node);
-		return await this.isy.sendRequest(`nodes/${this.address}/status`);
+		return node;
 	}
 
 	public async refreshNotes() {
@@ -347,10 +395,12 @@ export class ISYNode<
 			const result = await this.getNotes();
 			if (result !== null && result !== undefined) {
 				that.location = result.location ?? this.folder ?? '';
-				that.spokenName = result.spoken ?? this.folder ?? '';
+				that.spokenName = result.spoken ?? this.name ?? '';
+				if (result.isLoad) this.features &= Feature.HasLoad;
+
 				// if(result.spoken)
 			} else {
-				that.logger('No notes found.');
+				//that.logger('No notes found.','debug');
 			}
 			that.label = that.generateLabel.bind(that)(that.isy.displayNameFormat);
 			that.label = that.label ?? this.baseLabel;
@@ -360,27 +410,38 @@ export class ISYNode<
 		}
 	}
 	public async sendCommand(command: StringKeys<C>): Promise<any>;
-	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>;
+	public async sendCommand(
+		command: StringKeys<C>,
+		value: MaybeWithUOM,
+		parameters: Record<string | symbol, MaybeWithUOM | undefined>
+	): Promise<any>;
+	public async sendCommand(command: StringKeys<C>, value: MaybeWithUOM): Promise<any>;
+	public async sendCommand(
+		command: StringKeys<C>,
+		parameters: Record<string | symbol, MaybeWithUOM | undefined>
+	): Promise<any>;
 	async sendCommand(
 		command: StringKeys<C>,
-		valueOrParameters?: string | number | Record<string | symbol, string | number | undefined>,
-		parameters?: Record<string | symbol, string | number | undefined>
+		valueOrParameters?: MaybeWithUOM | Record<string | symbol, MaybeWithUOM | undefined>,
+		parameters?: Record<string | symbol, MaybeWithUOM | 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' ||
+			typeof valueOrParameters === 'boolean' ||
+			Array.isArray(valueOrParameters)
+		) {
+			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 (typeof valueOrParameters === 'object' && !Array.isArray(valueOrParameters)) {
+			return this.isy.sendNodeCommand(this, command, null, { ...valueOrParameters, ...parameters });
 		}
+
+		///return this.isy.sendNodeCommand(this, command, valueOrParameters, { ...parameters });
 	}
 
 	public async updateProperty(propertyName: string, value: any): Promise<any> {
@@ -391,24 +452,47 @@ export class ISYNode<
 		}
 		this.logger(`Updating property ${l.label}. incoming value: ${value} outgoing value: ${l.state.pendingValue}`);
 
-		return this.isy.sendRequest(`nodes/${this.address}/set/${propertyName}/${l.state.pendingValue}`).then((p) => {
+		return this.isy.sendRequest(`nodes/${this.address}/set/${propertyName}/${l.state.pendingValue}`).then(p => {
 			l.state.pendingValue = null;
 		});
 	}
 
+	toJSON() {
+		return {
+			...this,
+
+			initialized: this.initialized,
+			family: Family[this.family],
+			type: NodeType[this.type],
+			scenes: this.scenes?.map(s => {
+				return { address: s.address, name: s.name };
+			}),
+			commands: this.commands
+				? Object.entries(this.commands).map(([id, c]) => {
+						return {
+							id: id,
+							name: c.name,
+						};
+					})
+				: [],
+			isy: undefined,
+			parent: this.parent ? { address: this.parent.address, name: this.parent.name } : undefined,
+		};
+	}
+
 	// #endregion Public Methods (18)
 }
 
 export type Flatten<T, Level extends Number = 2, K = keyof T> = UnionToIntersection<
-	T extends Record<string, unknown> ?
-		K extends string ?
-			T[K] extends Record<string, unknown> ?
-				keyof T[K] extends string ?
-					{ [x in `${K}.${keyof T[K]}`]: T[K][TakeLast<x>] }
-				:	never
-			:	never
-		:	never
-	:	never
+	T extends Record<string, unknown>
+		? K extends string
+			? T[K] extends Record<string, unknown>
+				? keyof T[K] extends string
+					? { [x in `${K}.${keyof T[K]}`]: T[K][TakeLast<x>] }
+					: never
+				: never
+			: never
+		: never
 >;
 
 type Split<X> = X extends `${infer A}.${infer B}` ? [A, ...Split<B>] : never;
@@ -418,121 +502,6 @@ type Test = Flatten<{ a: { b: { c: string } } }>;
 
 export type DriverMap<T extends NodeList> = Flatten<{ [x in keyof T]: DriversOf<T[x]> }>;
 
-// export class ISYDeviceNodeOld<
-//   T extends Family,
-//   D extends DriverSignatures | {},
-//   C extends CommandSignatures | {},
-//   E extends string = string
-// >
-//   extends ISYNode<D, C, E>
-//   implements ISYDevice<T, D, C> {
-//   public declare family: T;
-
-//   public readonly typeCode: string;
-//   public readonly deviceClass: any;
-//   public readonly parentAddress: any;
-//   public readonly category: number;
-//   public readonly subCategory: number;
-//   public readonly type: any;
-//   public _parentDevice: ISYDeviceNode<T, any, any, any>;
-//   public readonly children: Array<ISYDeviceNode<T, any, any, any>> = [];
-//   public readonly scenes: ISYScene[] = [];
-
-//   public hidden: boolean = false;
-
-//   public _enabled: any;
-//   productName: string;
-//   model: string;
-//   modelNumber: string;
-//   version: string;
-//   isDimmable: boolean;
-
-//   constructor (isy: ISY, node: NodeInfo) {
-//     super(isy, node);
-
-//     this.family = node.family as T;
-//     this.nodeType = 1;
-//     this.type = node.type;
-//     this._enabled = node.enabled;
-//     this.deviceClass = node.deviceClass;
-//     this.parentAddress = node.pnode;
-//     const s = this.type.split(".");
-//     this.category = Number(s[0]);
-//     this.subCategory = Number(s[1]);
-
-//     // console.log(nodeDetail);
-//     if (this.parentAddress !== this.address && this.parentAddress !== undefined) {
-//       this._parentDevice = isy.getDevice(this.parentAddress) as unknown as ISYDeviceNode<T, Driver.Literal, string>;
-//       if (!isNullOrUndefined(this._parentDevice)) {
-//         this._parentDevice.addChild(this);
-//       }
-//     }
-//     if (Array.isArray(node.property)) {
-//       for (const prop of node.property) {
-//         this.local[prop.id] = this.convertFrom(prop.value, prop.uom, prop.id as Driver.Literal);
-//         this.formatted[prop.id] = prop.formatted;
-//         this.uom[prop.id] = prop.uom;
-//         this.logger(
-//           `Property ${Controls[prop.id].label} (${prop.id}) initialized to: ${this.local[prop.id]} (${this.formatted[prop.id]})`
-//         );
-//       }
-//     } else if (node.property) {
-//       this.local[node.property.id] = this.convertFrom(
-//         node.property.value,
-//         node.property.uom,
-//         node.property.id as Driver.Literal
-//       );
-//       this.formatted[node.property.id] = node.property.formatted;
-//       this.uom[node.property.id] = node.property.uom;
-//       this.logger(
-//         `Property ${Controls[node.property.id].label} (${node.property.id}) initialized to: ${this.local[node.property.id]} (${this.formatted[node.property.id]})`
-//       );
-//     }
-//   }
-
-//   public convertTo(value: any, UnitOfMeasure: number, propertyName: Driver.Literal = null): any {
-//     return value;
-//   }
-
-//   public convertFrom(value: any, UnitOfMeasure: number, propertyName: Driver.Literal = null): any {
-//     return value;
-//   }
-
-//   public override handleControlTrigger(controlName: string) {
-//     return this.emit("ControlTriggered", controlName);
-//   }
-
-//   public override handlePropertyChange(driver: any, value: any, formattedValue: string) {
-//     let changed = false;
-//     const priorVal = this.local[driver];
-//     try {
-//       const val = this.convertFrom(value, this.uom[driver]);
-
-//       if (this.local[driver] !== val) {
-//         this.logger(`Property ${Controls[driver].label} (${driver}) updated to: ${val} (${formattedValue})`);
-//         this.local[driver] = val;
-//         this.formatted[driver] = formattedValue;
-//         this.lastChanged = new Date();
-//         changed = true;
-//       } else {
-//         this.logger(`Update event triggered, property ${Controls[driver].label} (${driver}) is unchanged.`);
-//       }
-//       if (changed) {
-//         this.emit("PropertyChanged", driver, val, priorVal, formattedValue);
-
-//         this.scenes.forEach((element) => {
-//           this.logger(`Recalulating ${element.deviceFriendlyName}`);
-//           element.recalculateState();
-//         });
-//       }
-//     } catch (error) {
-//       this.logger(error, "error");
-//     } finally {
-//       return changed;
-//     }
-//   }
-//}
-
 export type NodeList = { [x: string]: ISYNode<any, any, any, any> };
 
 export type DriversOf<T> = T extends ISYNode<any, infer D, infer C, infer E> ? D : never;
@@ -544,13 +513,21 @@ 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 interface Factory<F extends Family, T extends ISYNode<F, any, any, any> = ISYNode<F, any, any, any>>
+		extends BaseFactory<T> {
+		Commands;
+		Drivers;
+	}
+
 	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;
+		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, any, any> ? T['commands'] : 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;
 
@@ -562,16 +539,19 @@ export namespace ISYNode {
 
 	export type EventNamesOf<T extends ISYNode> = EventTypesOf<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 DriverNamesOf<T> = T extends { Drivers }
+		? keyof T['Drivers']
+		: 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> = CommandsOf<T> extends { name: infer U } ? U : never;
+	export type CommandNamesOf<T> = T extends { Commands } ? keyof T['Commands'] : never;
 	export type List = NodeList;
 
 	export type DriverMap<T extends NodeList> = Flatten<{
@@ -594,27 +574,26 @@ export namespace ISYNode {
 
 	export type EventSignatures = Record<string, Event.Signature>;
 
+	export function getImplements(node: ISYNode<any, any, any, any> | typeof ISYNode): string[] {
+		return NodeFactory.getImplements(node);
+	}
+
 	//TODO: fix return types
 	/*export type WithCommands<C extends Command.Signatures<any>> = C extends Command.Signatures<infer U> ? {
       [K in C[U]["name"]]: C[K];
     } : never;*/
 
-	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'> {
+	/*export const With = <K extends Family, D extends DriverSignatures, C extends CommandSignatures, T extends Constructor<ISYNode<K, any, any, any>>>(base: T, drivers: D, commands: C) => {
+		return class extends base implements Omit<ISYNode<K, D, C>, 'events'> {
 			declare drivers: Driver.ForAll<D, false>;
 			declare commands: Command.ForAll<C>;
 		};
-	};
+	};*/
 
 	export type WithDrivers<D extends DriverSignatures> =
-		D extends Driver.Signatures<infer U extends keyof D> ?
-			{
-				[K in D[U] as K['name']]: K['value'];
-			}
-		:	never;
-
-	type test = WithDrivers<{
-		ST: { name: 'mode'; label: 'Mode'; uom: UnitOfMeasure.Boolean; value: boolean };
-		ERR: { name: 'resp'; label: 'Resp'; uom: UnitOfMeasure.Boolean; value: Error };
-	}>;
+		D extends Driver.Signatures<infer U extends keyof D>
+			? {
+					[K in D[U] as K['name']]: K['value'];
+				}
+			: never;
 }

package/src/ISYVariable.ts

@@ -1,8 +1,8 @@
 import { EventEmitter } from 'events';
 import { ISY } from './ISY.js';
-import { VariableType } from './ISYConstants.js';
+import { VariableType } from './VariableType.js';
 
-const varT = (t: typeof VariableType) => VariableType.Integer ? typeof Number : typeof String;
+const varT = (t: typeof VariableType) => (VariableType.Integer ? typeof Number : typeof String);
 
 type Variable<T extends VariableType> = T extends VariableType.Integer ? Number : String;
 
@@ -14,19 +14,19 @@ export class ISYVariable<P extends VariableType> extends EventEmitter {
 	public init: any;
 	public type: P;
 	public lastChanged: Date;
-	constructor(isy: ISY, id: number, name: string, type: VariableType) {
+	constructor(isy: ISY, id: number, name: string, type: P) {
 		super();
 		this.isy = isy;
 		this.id = id;
 		this.name = name;
 		this.value = undefined;
 		this.init = undefined;
+		this.type = type;
 
 		this.lastChanged = new Date();
 	}
 
-	public handleEvent(event: { eventInfo: { var: any }; })
-	{
+	public handleEvent(event: { eventInfo: { var: any } }) {
 		const varNode = event.eventInfo.var;
 		if (varNode !== null) {
 			const id = varNode.id;
@@ -39,8 +39,8 @@ export class ISYVariable<P extends VariableType> extends EventEmitter {
 			const hour = parseInt(varNode.ts.substr(9, 2));
 			const min = parseInt(varNode.ts.substr(12, 2));
 			const sec = parseInt(varNode.ts.substr(15, 2));
-			 this.lastChanged = new Date(year, month, day, hour, min, sec);
-			this.emit('ValueChanged',this.value, priorVal);
+			this.lastChanged = new Date(year, month, day, hour, min, sec);
+			this.emit('ValueChanged', this.value, priorVal);
 		}
 	}
 
@@ -49,5 +49,4 @@ export class ISYVariable<P extends VariableType> extends EventEmitter {
 		this.value = value;
 		return p;
 	}
-
 }