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

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.6-alpha.2",
+    "version": "1.0.8-alpha.0",
     "author": {
         "name": "Pradeep Mouli"
     },
@@ -74,5 +74,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "3de345bb19ced109099ec8beb4707293e1924922"
+    "gitHead": "4b88acc1e9ee5625c06cfa8cf7359aa0c3ff9faf"
 }

package/src/CodeGeneration/CodeFactory.ts

@@ -290,19 +290,27 @@ export class CodeFactory {
 		return ts.factory.createLiteralTypeNode(this.createStringLiteral(literal));
 	}
 
-	createNumericLiteral(value: number): ts.NumericLiteral {
-		return ts.factory.createNumericLiteral(value.toString());
+	createLiteral(value: string | number): ts.LiteralExpression {
+		if (typeof value === 'number') {
+			return this.createNumericLiteral(value as number);
+		}
+
+		return this.createStringLiteral(value);
+	}
+
+	createNumericLiteral(value: number, flags?: ts.TokenFlags): ts.NumericLiteral {
+		return ts.factory.createNumericLiteral(value.toString(), flags);
 	}
 
 	createStringLiteral(text: string): ts.StringLiteral {
-		return ts.factory.createStringLiteral(text);
+		return ts.factory.createStringLiteral(text, true);
 	}
 
 	createKeywordTypeNode(kind: ts.KeywordTypeSyntaxKind): ts.KeywordTypeNode {
 		return ts.factory.createKeywordTypeNode(kind);
 	}
 
-	createTypePredicateNode(parameterName: ts.Identifier, type: ts.TypeNode): ts.TypePredicateNode {
+	createTypePredicateNode(parameterName: ts.Identifier | string, type: ts.TypeNode): ts.TypePredicateNode {
 		return ts.factory.createTypePredicateNode(undefined, parameterName, type);
 	}
 
@@ -310,15 +318,15 @@ export class CodeFactory {
 		return ts.factory.createBinaryExpression(left, operator, right);
 	}
 
-	createPropertyAccessExpression(expression: ts.Expression, name: string): ts.PropertyAccessExpression {
-		return ts.factory.createPropertyAccessExpression(expression, this.createIdentifier(name)!);
+	createPropertyAccessExpression(expression: ts.Expression, name: string | ts.MemberName): ts.PropertyAccessExpression {
+		return ts.factory.createPropertyAccessExpression(expression, name);
 	}
 
-	createHeritageClause(token: ts.SyntaxKind.ExtendsKeyword | ts.SyntaxKind.ImplementsKeyword, types: ts.ExpressionWithTypeArguments[]): ts.HeritageClause {
+	createHeritageClause(token: ts.SyntaxKind.ExtendsKeyword | ts.SyntaxKind.ImplementsKeyword, ...types: ts.ExpressionWithTypeArguments[]): ts.HeritageClause {
 		return ts.factory.createHeritageClause(token, types);
 	}
 
-	createExpressionWithTypeArguments(expression: ts.Expression, typeArguments?: ts.TypeNode[]): ts.ExpressionWithTypeArguments {
+	createExpressionWithTypeArguments(expression: ts.Expression, ...typeArguments: ts.TypeNode[]): ts.ExpressionWithTypeArguments {
 		return ts.factory.createExpressionWithTypeArguments(expression, typeArguments);
 	}
 	createBlock(multiLine: boolean, ...statements: ts.Statement[]): ts.Block;

package/src/CodeGeneration/NodeClassFactory.ts

@@ -76,7 +76,7 @@ export class NodeClassFactory extends CodeFactory {
 
 	public createNodeClass<T extends Family>(nodeClassDef: NodeClassDefinition<T>) {
 		let path = `${NodeClassFactory.basePath}/${Family[nodeClassDef.family]}/Generated/${nodeClassDef.name}.ts`;
-		let sf = ts.createSourceFile(path, '', ts.ScriptTarget.ES2023, true, ts.ScriptKind.TS);
+		let sf = ts.createSourceFile(path, '', ts.ScriptTarget.ES2024, true, ts.ScriptKind.TS);
 		//@ts-expect-error
 
 		sf.statements = [
@@ -163,7 +163,7 @@ export class NodeClassFactory extends CodeFactory {
 			),
 
 			factory.createClassDeclaration(
-				[factory.createToken(ts.SyntaxKind.ExportKeyword)],
+				[],
 				factory.createIdentifier(`${nodeClassDef.name}Node`),
 				undefined,
 				[
@@ -303,7 +303,7 @@ export class NodeClassFactory extends CodeFactory {
 							])
 						],
 						[
-							factory.createPropertySignature(
+							/*factory.createPropertySignature(
 								undefined,
 								factory.createIdentifier('nodeDefId'),
 								undefined,
@@ -314,7 +314,7 @@ export class NodeClassFactory extends CodeFactory {
 										)
 									)
 								:	NodeClassFactory.instance.createLiteralTypeNode(nodeClassDef.id)
-							)
+							)*/
 						]
 					),
 
@@ -472,7 +472,8 @@ export class NodeClassFactory extends CodeFactory {
 			newLineCharacter: '\n',
 			trimTrailingWhitespace: true,
 			ensureNewLineAtEndOfFile: true,
-			indentStyle: ts.IndentStyle.Smart
+			indentStyle: ts.IndentStyle.Smart,
+
 		});
 		let currentKind = ts.SyntaxKind.Unknown;
 		for (const s of f.getStatements()) {
@@ -652,10 +653,7 @@ export class NodeClassFactory extends CodeFactory {
 				factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier('Driver'), factory.createIdentifier('create')), undefined, [
 					factory.createStringLiteral(def.id),
 					factory.createThis(),
-					factory.createAsExpression(
-						factory.createPropertyAccessExpression(factory.createIdentifier('nodeInfo'), factory.createIdentifier('property')),
-						factory.createTypeReferenceNode(factory.createIdentifier('DriverState'), undefined)
-					),
+					factory.createElementAccessExpression(factory.createPropertyAccessExpression(factory.createIdentifier('nodeInfo'), factory.createIdentifier('state')), this.createStringLiteral(def.id)),
 					factory.createObjectLiteralExpression(
 						[
 							factory.createPropertyAssignment(

package/src/Definitions/Global/Commands.ts

@@ -1,7 +1,7 @@
 import { Converter } from '../../Converters.js';
 import type { ISYNode } from '../../ISYNode.js';
 import type { Driver } from './Drivers.js';
-import type { UnitOfMeasure } from './UOM.js';
+import { UnitOfMeasure } from './UOM.js';
 
 /*export class Command<T extends string> extends Function {
 
@@ -15,10 +15,10 @@ import type { UnitOfMeasure } from './UOM.js';
 }*/
 
 export interface Parameter<P, T> {
-	id: P;
-	name: string;
+	id?: P;
+	name?: string;
 
-	label: string;
+	label?: string;
 	value?: T;
 	uom: UnitOfMeasure;
 	serverUom?: UnitOfMeasure;
@@ -82,14 +82,14 @@ export namespace Command {
 
 
 	function getCommandFunctionSignature<P extends { [x: string]: Parameter<string, any> } | Parameter<string, any> | null> (command: string, node: ISYNode<any,any,any,any>,parameters?: P): Function {
-		if (parameters === null) {
-			return function (): Promise<boolean> {
+		if (!parameters) {
+			return  () => {
 				return node.sendCommand(command);
 			};
 		}
 
 		else if (isParameterCollection(parameters)) {
-			let cmd = function (params: { [x in keyof P]: typeof parameters[x]['value'] }): Promise<boolean> {
+			let cmd : any = (params: { [x in keyof P]: typeof parameters[x]['value'] }) => {
 				for (let key in params) {
 					let p = parameters[key];
 					if (p.converter) {
@@ -97,23 +97,25 @@ export namespace Command {
 					}
 				}
 				return node.sendCommand(command, params);
-			} as any;
+			};
+			Object.defineProperty(cmd, 'parameters', {});
 			for (let key in parameters) {
 				let p = parameters[key];
-				cmd.parameters[key] = p;
+
 				let srvUom = node.drivers[p.driver]?.serverUom;
-				if (node.drivers[parameters[key].driver]?.serverUom) {
-					cmd.parameters[key].serverUom = node.drivers[parameters[key].driver].serverUom;
-					if (srvUom) {
+				if (srvUom)
+				{
+					if(srvUom !== p.uom) {
 						cmd.parameters[key].converter = Converter.get(p.uom, srvUom).to;
 						cmd.parameters[key].serverUom = srvUom;
 					}
 				}
+
 			}
 			return cmd;
 		}
 		else if(parameters.name) {
-			let cmd = function (value: P['value']): Promise<boolean> {
+			let cmd = function (value): Promise<boolean> {
 				if(parameters.converter) {
 					value = parameters.converter(value);
 				}
@@ -145,6 +147,7 @@ export namespace Command {
 		return cmd;
 	}
 
+
 	type Commands = {
 		BEEP: ((value: number) => Promise<boolean>) & { label: 'Beep'; name: 'beep' };
 		BL: ((value: number) => Promise<boolean>) & { label: 'Backlight'; name: 'backlight' };

package/src/Definitions/Global/Drivers.ts

@@ -264,9 +264,9 @@ export interface Driver<
 	U extends UnitOfMeasure,
 	T = number,
 	SU extends UnitOfMeasure = U,
-	ST = number,
-	N = string,
-	L = string
+	ST = T,
+	N = D,
+	L = N
 > {
 	// #region Properties (8)
 
@@ -282,8 +282,11 @@ export interface Driver<
 		value: T;
 		formattedValue?: any;
 		pendingValue: T;
+		rawValue?: ST;
 	};
-	uom: U;
+
+	initialized: boolean;
+		uom: U;
 
 	// #endregion Properties (8)
 
@@ -301,8 +304,9 @@ export interface StatelessDriver<
 	U extends UnitOfMeasure,
 	T = number,
 	SU extends UnitOfMeasure = U,
-	N = string,
-	L = string
+	ST = T,
+	N = D,
+	L = N
 > {
 	// #region Properties (9)
 
@@ -318,6 +322,7 @@ export interface StatelessDriver<
 		value: T;
 		formattedValue?: any;
 		pendingValue: T;
+		rawValue?: ST;
 	};
 	stateless: true;
 	uom: U;
@@ -338,10 +343,10 @@ 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 };
+	export type Signature<U extends UnitOfMeasure = UnitOfMeasure, V = any, SU extends UnitOfMeasure = U, N = string, L = N> = { uom: U; value: V; name: N; label: L };
 
 	export type Signatures<D> = UnionToIntersection<
-		D extends string ? { [K in D]: Signature<UnitOfMeasure, any, UnitOfMeasure, string, string> }
+		D extends string ? { [K in D]: Signature<UnitOfMeasure, any, UnitOfMeasure, K, K> }
 		: D extends { [K in keyof D]: Signature } ? D
 		: never
 	>;
@@ -365,21 +370,22 @@ export namespace Driver {
 		};
 	};
 
-
-	export type For<D extends string, T, S extends boolean = false> = T extends Signature<infer U, infer V, infer SU, infer N, infer L> ? StatelessOrStateful<D, U, V, N, L, S> : never;
+	export type For<D extends string, T, S extends boolean = false> = T extends Signature<infer U, infer V, infer SU, infer N, infer L> ? StatelessOrStateful<D, U, V, SU, V, N, L, S> : never;
 
 	export type ForAll<T, S extends boolean = false> = {
 		[K in StringKeys<T>]: T[K] extends Signature<UnitOfMeasure, any, UnitOfMeasure, string, string> ? For<K, T[K], S> : never;
 	};
 
-	type test2 = ForAll<Drivers>;
+	export type SignaturesOf<D> = D extends ForAll<infer R> ? R : never;
+
+	type test2 = SignaturesOf<ForAll<Drivers>>;
 
 	export type Type = DriverType;
 	export type Literal = EnumLiteral<DriverType>;
 	export type LiteralWithExtensions = Literal | `${string}.${Literal}`;
 	export type LiteralWithType = EnumWithLiteral<DriverType>;
-	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>;
+	type StatelessOrStateful<D extends string, U extends UnitOfMeasure, T = number, SU extends UnitOfMeasure = U, ST = T, N = D, L = N, S extends boolean = false> =
+		S extends true ? StatelessDriver<D, U, T, SU, ST, N, L> : Driver<D, U, T, SU, ST, N, L>;
 
 	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>,
@@ -389,7 +395,7 @@ export namespace Driver {
 		driverSignature?: { uom: U; label: L; name: N },
 		stateless?: S,
 		converter?: Converter<any, T>
-	): StatelessOrStateful<D, U, T, N, L, S> {
+	): StatelessOrStateful<D, U, T, UnitOfMeasure, any, N, L, S> {
 		const query = async () => {
 			return await node.readProperty(driver as D);
 		};
@@ -403,19 +409,20 @@ export namespace Driver {
 				state: {
 					initial: true,
 					value: initState?.value, //TODO include converter
-					formattedValue: initState.formatted,
+					formattedValue: initState?.formatted,
 					pendingValue: null
 				},
 				query,
 				get value() {
 					return query().then((p) => p.value) as Promise<T>;
 				},
-				name: initState.name ?? driverSignature.name ?? driverSignature.label ?? driver,
+				name: initState?.name ?? driverSignature.name ?? driverSignature.label ?? driver,
 				label: driverSignature.label ?? driver
-			} as unknown as StatelessOrStateful<D, U, T, N, L, typeof stateless>;
+			} as StatelessOrStateful<D, U, T, UnitOfMeasure, any, N, L, typeof stateless>;
 		}
 		var c = {
 			id: driver as D,
+			initialized: initState ? true : false,
 			uom: driverSignature?.uom as U,
 			serverUom: initState?.uom != driverSignature?.uom ? initState?.uom : undefined,
 			state: {
@@ -424,35 +431,45 @@ export namespace Driver {
 					initState ?
 						converter ? converter.from(initState.value)
 						: driverSignature?.uom && initState?.uom != driverSignature?.uom ? Converter.convert(initState.uom, driverSignature.uom, initState.value)
-					:	initState.value : null,
+						: initState.value
+					:	null,
 				rawValue: initState ? initState.value : null,
 				formattedValue: initState ? initState.formatted : null,
 				pendingValue: null
 			},
 			async query() {
 				let s = await query();
-				this.state.value = converter ? converter.from(s.value) : this.uom !== s.uom ? Converter.convert(s.value, s.uom, this.uom) : s.value;
+				this.state.value =
+					converter ? converter.from(s.value)
+					: this.uom !== s.uom ? Converter.convert(s.value, s.uom, this.uom)
+					: s.value;
 				this.state.formattedValue = s.formatted;
 				this.state.rawValue = s.value;
 				return s;
 			},
-			apply(state: DriverState, notify = false) {
-				let previousValue = this.state.rawValue;
-				this.state.rawValue = state.value;
-				if (previousValue === this.state.rawValue) {
-					return false;
-				}
-				if (state.uom != this.uom) {
-					this.serverUom == state.uom;
-					this.state.value = converter ? converter.from(this.state.rawValue) : Converter.convert(state.uom, this.uom, this.state.rawValue);
-				} else if (converter) {
-					this.state.value = converter.from(state.value);
-				} else {
-					this.state.value = state.value;
+			apply(state: DriverState, notify = true) {
+				if (state.id == this.id) {
+
+					let previousValue = this.state.rawValue;
+					this.state.rawValue = state.value;
+					if (previousValue === this.state.rawValue) {
+						return false;
+					}
+					if (state.uom != this.uom) {
+						this.serverUom == state.uom;
+						this.state.value = converter ? converter.from(this.state.rawValue) : Converter.convert(state.uom, this.uom, this.state.rawValue);
+					} else if (converter) {
+						this.state.value = converter.from(state.value);
+					} else {
+						this.state.value = state.value;
+					}
+					this.state.formattedValue = state.formatted;
+					if (notify) node.events.emit(`${this.name}Changed`, driver as D, this.state.value, previousValue, this.state.formattedValue);
+					if (!this.initialized) {
+						this.initialized = true;
+					}
+					return true;
 				}
-				this.state.formattedValue = state.formatted;
-				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 = true) {
 				let previousValue = this.state.rawValue;
@@ -470,6 +487,10 @@ export namespace Driver {
 					return false;
 				}
 				if (notify) node.events.emit(`${this.name}Changed`, driver as D, this.state.value, previousValue, formattedValue);
+				if (!this.initialized) {
+					
+					this.initialized = true;
+				}
 				return true;
 			},
 			get value() {
@@ -486,7 +507,7 @@ export namespace Driver {
 		//     }
 
 		//});
-		return c as unknown as StatelessOrStateful<D, U, T, N, L, typeof stateless>;
+		return c as StatelessOrStateful<D, U, T, UnitOfMeasure, any, N, L, typeof stateless>;
 	}
 }
 

package/src/Definitions/Global/Events.ts

@@ -20,7 +20,7 @@ export namespace Event {
 
 	export type Signatures = { [x: string]: Signature };
 
-	export type DriverToEvent<D extends Driver.Signature> = { name: `${D['name']}Changed`; value: D['value']; uom: D['uom'] };
+	export type DriverToEvent<D extends Driver.Signature> = { name: `${D['name']}Changed` | `${D['name']}Initialized`, value: D['value']; uom: D['uom'] };
 
 	export type CommandToEvent<C extends Command.Signature> = { name: `${C['name']}Triggered` };
 
@@ -30,8 +30,8 @@ export namespace Event {
 		: S extends { name: string; command: string } ? { on(eventName: S['name'], listener: (command: S['command']) => void): N }
 		: { on(eventName: S['name'], listener: (...args: any[]) => void): N };
 
-	export type ForAll<E extends string, D extends ISYNode.DriverSignatures, C extends ISYNode.CommandSignatures> = {
-		[x in E]: x extends keyof D ? { name: `${D[x]['name']}Changed`; driver: x; value: D[x]['value']; uom: UnitOfMeasure }
+	export type ForAll<E extends ISYNode.EventSignatures, D extends ISYNode.DriverSignatures, C extends ISYNode.CommandSignatures> = {
+		[x in keyof E | keyof D]: x extends keyof D ? { name: `${D[x]['name']}Changed`; driver: x; value: D[x]['value']; uom: UnitOfMeasure }
 		: x extends keyof C ? { name: `${C[x]['name']}Triggered`; command: x }
 		: { name: x };
 	};
@@ -44,7 +44,7 @@ export namespace Event {
 
 	export type FunctionSigFor<E extends Signatures, N> = UnionToIntersection<HandlerSignature<ObjectToUnion<E>, N>>;
 
-	type test1 = ForAll<'ST', Driver.Signatures<{ ST: { name: 'Status'; label: 'Status'; uom: UnitOfMeasure; value: boolean; formatted: string } } | 'RR'>, any>;
+	type test1 = ForAll<{'ST'}, Driver.Signatures<{ ST: { name: 'Status'; label: 'Status'; uom: UnitOfMeasure; value: boolean; formatted: string } } | 'RR'>, any>;
 	type test = FunctionSigFor<test1, test1> & Omit<EventEmitter, 'on'>;
 
 	export class NodeEventEmitter<N extends ISYNode<any, any, any, any>> extends EventEmitter {

package/src/Definitions/Insteon/generated/Boolean.ts

@@ -2,3 +2,12 @@ export enum Boolean {
     False = 0,
     True = 255
 }
+
+export namespace Boolean {
+	export function toBoolean(value: Boolean): boolean {
+		return value === Boolean.True;
+	}
+	export function fromBoolean(value: boolean): Boolean {
+		return value ? Boolean.True : Boolean.False;
+	}
+}

package/src/Definitions/Insteon/generated/Error.ts

@@ -2,3 +2,12 @@ export enum Error {
     True = 0,
     False = 1
 }
+
+export namespace Error {
+	export function toBoolean(value: Error): boolean {
+		return value === Error.True;
+	}
+	export function fromBoolean(value: boolean): Error {
+		return value ? Error.True : Error.False;
+	}
+}

package/src/Definitions/Insteon/generated/Lock.ts

@@ -1,4 +1,32 @@
+import exp from 'constants';
+
 export enum Lock {
     Unlocked = 0,
     Locked = 100
 }
+
+
+export namespace Lock {
+	export function toString(value: number): string {
+		switch (value) {
+			case Lock.Unlocked: return "Unlocked";
+			case Lock.Locked: return "Locked";
+			default: return value.toString();
+		}
+	}
+	export function toEnum(value: string): number {
+		switch (value) {
+			case "Unlocked": return Lock.Unlocked;
+			case "Locked": return Lock.Locked;
+			default: return parseInt(value);
+		}
+	}
+
+	export function toBoolean(value: Lock): boolean {
+		return value === Lock.Locked;
+	}
+
+	export function fromBoolean(value: boolean): Lock {
+		return value ? Lock.Locked : Lock.Unlocked;
+	}
+}

package/src/Definitions/Insteon/generated/OnLevelRelay.ts

@@ -2,3 +2,14 @@ export enum OnLevelRelay {
     Off = 0,
     On = 100
 }
+
+
+export namespace OnLevelRelay {
+	export function toBoolean(value: OnLevelRelay): boolean {
+		return value === OnLevelRelay.On;
+	}
+
+	export function fromBoolean(value: boolean): OnLevelRelay {
+		return value ? OnLevelRelay.On : OnLevelRelay.Off;
+	}
+}

package/src/Devices/Brultech/Generated/Channel.ts

@@ -17,16 +17,16 @@ const nodeDefId = "BTChannel";
 type Commands = Channel.Commands;
 type Drivers = Channel.Drivers;
 
-export class ChannelNode extends Base<Drivers, Commands> implements Channel.Interface {
+class ChannelNode extends Base<Drivers, Commands> implements Channel.Interface {
 	public override readonly commands = {};
 	static override nodeDefId = "BTChannel";
-	static override implements = ["BTChannel"];
-	declare readonly nodeDefId: "BTChannel";
+	static override implements = ['BTChannel'];
+	declare readonly nodeDefId: 'BTChannel';
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Watt, label: "Status", name: "status" });
-		this.drivers.TPW = Driver.create("TPW", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.KilowattsPerHour, label: "Total Energy", name: "totalEnergy" });
-		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.Watt, label: "Status", name: "status" });
+		this.drivers.TPW = Driver.create("TPW", this, nodeInfo.state['TPW'], { uom: UnitOfMeasure.KilowattsPerHour, label: "Total Energy", name: "totalEnergy" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
 	public get status(): number {
 		return this.drivers.ST?.value;
@@ -43,13 +43,12 @@ NodeFactory.register(ChannelNode);
 
 export namespace Channel {
 	export interface Interface extends Omit<InstanceType<typeof ChannelNode>, keyof ISYDeviceNode<any, any, any, any>> {
-		nodeDefId: "BTChannel";
 	}
 	export function is(node: ISYNode<any, any, any, any>): node is ChannelNode {
-		return ["BTChannel"].includes(node.nodeDefId);
+		return ['BTChannel'].includes(node.nodeDefId);
 	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is ChannelNode {
-		return ["BTChannel", "BTMain"].includes(node.nodeDefId);
+		return ['BTChannel', "BTMain"].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new ChannelNode(isy, nodeInfo);

package/src/Devices/Brultech/Generated/Main.ts

@@ -17,21 +17,21 @@ const nodeDefId = "BTMain";
 type Commands = Main.Commands;
 type Drivers = Main.Drivers;
 
-export class MainNode extends Base<Drivers, Commands> implements Main.Interface {
+class MainNode extends Base<Drivers, Commands> implements Main.Interface {
 	public override readonly commands = {
 		QUERY: this.query
 	};
 	static override nodeDefId = "BTMain";
-	static override implements = ["BTMain"];
-	declare readonly nodeDefId: "BTMain";
+	static override implements = ['BTMain'];
+	declare readonly nodeDefId: 'BTMain';
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Watt, label: "Status", name: "status" });
-		this.drivers.TPW = Driver.create("TPW", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.KilowattsPerHour, label: "Total Energy", name: "totalEnergy" });
-		this.drivers.CV = Driver.create("CV", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Volt, label: "Current Voltage", name: "currentVoltage" });
-		this.drivers.CC = Driver.create("CC", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Ampere, label: "Current Current", name: "currentCurrent" });
-		this.drivers.PPW = Driver.create("PPW", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Watt, label: "Polarized Power", name: "polarizedPower" });
-		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.Watt, label: "Status", name: "status" });
+		this.drivers.TPW = Driver.create("TPW", this, nodeInfo.state['TPW'], { uom: UnitOfMeasure.KilowattsPerHour, label: "Total Energy", name: "totalEnergy" });
+		this.drivers.CV = Driver.create("CV", this, nodeInfo.state['CV'], { uom: UnitOfMeasure.Volt, label: "Current Voltage", name: "currentVoltage" });
+		this.drivers.CC = Driver.create("CC", this, nodeInfo.state['CC'], { uom: UnitOfMeasure.Ampere, label: "Current Current", name: "currentCurrent" });
+		this.drivers.PPW = Driver.create("PPW", this, nodeInfo.state['PPW'], { uom: UnitOfMeasure.Watt, label: "Polarized Power", name: "polarizedPower" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
 	async query() { return this.sendCommand("QUERY"); }
 	public get status(): number {
@@ -58,13 +58,12 @@ NodeFactory.register(MainNode);
 
 export namespace Main {
 	export interface Interface extends Omit<InstanceType<typeof MainNode>, keyof ISYDeviceNode<any, any, any, any>> {
-		nodeDefId: "BTMain";
 	}
 	export function is(node: ISYNode<any, any, any, any>): node is MainNode {
-		return ["BTMain"].includes(node.nodeDefId);
+		return ['BTMain'].includes(node.nodeDefId);
 	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is MainNode {
-		return ["BTMain"].includes(node.nodeDefId);
+		return ['BTMain'].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new MainNode(isy, nodeInfo);