isy-nodejs 1.0.2-alpha.6 → 1.0.3-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.2-alpha.6",
+    "version": "1.0.3-alpha.0",
     "author": {
         "name": "Pradeep Mouli"
     },
@@ -57,12 +57,14 @@
         "@matter/types": "^0.11.4",
         "@project-chip/matter-node.js": "^0.11.4",
         "@project-chip/matter.js": "^0.11.4",
+        "@types/ws": "^8.5.13",
         "axios": "^1.7.7",
         "fast-xml-parser": "^4.5.0",
         "faye-websocket": "^0.11.4",
         "mocha": "^10.8.2",
         "p-queue": "^8.0.1",
         "winston": "^3.17.0",
+        "ws": "^8.18.0",
         "xml2js": "^0.6.2"
     },
     "bugs": {
@@ -71,5 +73,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "669e56896392dea34e29a2f90f82d0b904c696e9"
+    "gitHead": "7bc1560e617cbcb61c29680bd33ea63e2660f472"
 }

package/src/CodeGeneration/CodeFactory.ts

@@ -1,4 +1,6 @@
+import { unique } from 'moderndash';
 import ts, { ModifierFlags, type ModifierSyntaxKind, type PunctuationSyntaxKind } from 'typescript';
+import { types } from 'util';
 
 type ParameterType<F> = F extends (arg0: infer P) => any ? P : never;
 
@@ -207,10 +209,17 @@ export class CodeFactory {
 				return a.typeName.text === b.typeName.text;
 			}
 		}
+		if(a.kind === ts.SyntaxKind.NumberKeyword || a.kind === ts.SyntaxKind.StringKeyword || a.kind === ts.SyntaxKind.BigIntKeyword)
+		{
+			return a.kind === b.kind;
+		}
 		return false;
 	}
 
 	createUnionTypeNode(...types: ts.TypeNode[]): ts.UnionTypeNode {
+		let t = unique(types, this.typesEqual);
+		/*try
+		{
 		let t = [types[0]];
 		for (let i = 1; i < types.length; i++) {
 			if (types[i].kind !== ts.SyntaxKind.NeverKeyword) {
@@ -219,7 +228,14 @@ export class CodeFactory {
 				} else if (!t.some((x) => this.typesEqual(x, types[i]))) t.push(types[i]);
 			}
 		}
-		return ts.factory.createUnionTypeNode(types);
+			return ts.factory.createUnionTypeNode(t);
+		}
+		catch(e)
+		{*/
+			//console.warn(e);
+			return ts.factory.createUnionTypeNode(t);
+		//}
+
 	}
 
 	createIntersectionTypeNode(types: ts.TypeNode[]): ts.IntersectionTypeNode {
@@ -311,7 +327,7 @@ export class CodeFactory {
 		if(typeof multiLine === 'boolean') {
 			return ts.factory.createBlock(statements, multiLine);
 		}
-		return ts.factory.createBlock([multiLine, ...statements]);
+		return ts.factory.createBlock([multiLine, ...statements],true);
 
 	}
 

package/src/CodeGeneration/EnumFactory.ts

@@ -1,5 +1,5 @@
 import { factory } from "typescript";
-import { createWrappedNode, ts, type EnumDeclaration, EnumMember, Identifier } from 'ts-morph'
+import { createWrappedNode, ts, type EnumDeclaration, EnumMember, Identifier} from 'ts-morph'
 import { UnitOfMeasure } from "../Definitions/Global/UOM.js";
 
 import type {
@@ -7,6 +7,7 @@ import type {
   DriverDefinition,
   ParameterDefinition,
   CommandDefinition,
+  DataTypeDefinition,
 } from "../Model/ClassDefinition.js";
 import { EnumDefinition, EnumDefinitionMap } from "../Model/EnumDefinition.js";
 import { isGeneratorFunction } from "util/types";
@@ -136,7 +137,7 @@ function createDriverInitializationStatement(def: DriverDefinition): ts.Statemen
                 factory.createIdentifier("uom"),
                 factory.createPropertyAccessExpression(
                   factory.createIdentifier("UnitOfMeasure"),
-                  factory.createIdentifier(UnitOfMeasure[Object.values(def.dataType)[0]?.uom] ?? "Unknown")
+                  factory.createIdentifier(UnitOfMeasure[def.dataType[0]?.uom] ?? "Unknown")
                 )
               ),
               factory.createPropertyAssignment(
@@ -153,7 +154,7 @@ function createDriverInitializationStatement(def: DriverDefinition): ts.Statemen
   );
 }
 
-function createDriverSignatureReturnType(def: DriverDefinition["dataType"]["AbsoluteHumidity"]): ts.TypeNode {
+function createDriverSignatureReturnType(def: DataTypeDefinition): ts.TypeNode {
   if (def.enum) {
     return factory.createUnionTypeNode(
       Object.keys(def.values).map((p) => factory.createLiteralTypeNode(factory.createNumericLiteral(p)))
@@ -161,7 +162,7 @@ function createDriverSignatureReturnType(def: DriverDefinition["dataType"]["Abso
   } else return factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
 }
 
-function createDriverPropertyReturnType(def: DriverDefinition["dataType"]["AbsoluteHumidity"]): ts.TypeNode {
+function createDriverPropertyReturnType(def: DataTypeDefinition): ts.TypeNode {
   if (def.enum) {
     {
       if (Object.keys(def.values).length == 2) {

package/src/CodeGeneration/NodeClassFactory.ts

@@ -35,7 +35,8 @@ export class NodeClassFactory extends CodeFactory {
 			useTrailingCommas: false,
 			indentationText: IndentationText.Tab,
 			newLineKind: ts.NewLineKind.CarriageReturnLineFeed,
-			insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: true
+			insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: true,
+
 		}
 	});
 
@@ -336,7 +337,7 @@ export class NodeClassFactory extends CodeFactory {
 							)
 						],
 						factory.createTypePredicateNode(undefined, factory.createIdentifier('node'), factory.createTypeReferenceNode(factory.createIdentifier(`${nodeClassDef.name}Node`), undefined)),
-						NodeClassFactory.instance.createBlock(
+						NodeClassFactory.instance.createBlock(true,
 							NodeClassFactory.instance.createReturnStatement(
 								factory.createCallExpression(
 									factory.createPropertyAccessExpression(
@@ -624,7 +625,7 @@ export class NodeClassFactory extends CodeFactory {
 			[factory.createToken(ts.SyntaxKind.PublicKeyword)],
 			factory.createIdentifier(def.name),
 			[],
-			NodeClassFactory.instance.createUnionTypeNode(...Object.values(def.dataType).map((p) => NodeClassFactory.instance.createDriverPropertyReturnType(p, def))),
+			NodeClassFactory.instance.createUnionTypeNode(...def.dataType?.map((p) => NodeClassFactory.instance.createDriverPropertyReturnType(p, def))),
 			factory.createBlock(
 				[
 					factory.createReturnStatement(
@@ -656,7 +657,7 @@ export class NodeClassFactory extends CodeFactory {
 						[
 							factory.createPropertyAssignment(
 								factory.createIdentifier('uom'),
-								factory.createPropertyAccessExpression(factory.createIdentifier('UnitOfMeasure'), factory.createIdentifier(UnitOfMeasure[parseInt(Object.keys(def.dataType)[0])] ?? 'Unknown'))
+								factory.createPropertyAccessExpression(factory.createIdentifier('UnitOfMeasure'), factory.createIdentifier(UnitOfMeasure[def.dataType[0]?.uom] ?? 'Unknown'))
 							),
 							factory.createPropertyAssignment(factory.createIdentifier('label'), factory.createStringLiteral(def.label)),
 							factory.createPropertyAssignment(factory.createIdentifier('name'), factory.createStringLiteral(def.name))
@@ -707,7 +708,7 @@ export class NodeClassFactory extends CodeFactory {
 					factory.createIdentifier('uom'),
 					undefined,
 					def.dataType ?
-						NodeClassFactory.instance.createUnionTypeNode(...Object.values(def.dataType).map((p) => NodeClassFactory.instance.createTypeNodeForUOM(p.uom)))
+						NodeClassFactory.instance.createUnionTypeNode(...def.dataType?.map((p) => NodeClassFactory.instance.createTypeNodeForUOM(p.uom)))
 					:	factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)
 				),
 				factory.createPropertySignature(
@@ -715,7 +716,7 @@ export class NodeClassFactory extends CodeFactory {
 					factory.createIdentifier('value'),
 					undefined,
 					def.dataType ?
-						NodeClassFactory.instance.createUnionTypeNode(...Object.values(def.dataType).map((p) => NodeClassFactory.instance.createDriverSignatureReturnType(p, def)))
+						NodeClassFactory.instance.createUnionTypeNode(...def.dataType.map((p) => NodeClassFactory.instance.createDriverSignatureReturnType(p, def)))
 					:	factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)
 				),
 				factory.createPropertySignature(undefined, factory.createIdentifier('label'), undefined, factory.createLiteralTypeNode(factory.createStringLiteral(def.label))),
@@ -748,7 +749,7 @@ export class NodeClassFactory extends CodeFactory {
 			factory.createIdentifier(def.name ?? 'value'),
 			def.optional ? factory.createToken(ts.SyntaxKind.QuestionToken) : undefined,
 			def.dataType ?
-				NodeClassFactory.instance.createUnionTypeNode(...Object.values(def.dataType).map((p) => NodeClassFactory.instance.createCommandParameterType(p, def)))
+				NodeClassFactory.instance.createUnionTypeNode(...def.dataType?.map((p) => NodeClassFactory.instance.createCommandParameterType(p, def)))
 			:	factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
 			undefined
 		);
@@ -761,7 +762,7 @@ export class NodeClassFactory extends CodeFactory {
 			factory.createIdentifier(def.id ?? 'value'),
 			def.optional ? factory.createToken(ts.SyntaxKind.QuestionToken) : undefined,
 			def.dataType ?
-				NodeClassFactory.instance.createUnionTypeNode(...Object.values(def.dataType).map((p) => NodeClassFactory.instance.createCommandParameterType(p, def)))
+				NodeClassFactory.instance.createUnionTypeNode(...def.dataType?.map((p) => NodeClassFactory.instance.createCommandParameterType(p, def)))
 			:	factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
 			undefined
 		);

package/src/Converters.ts

@@ -15,20 +15,20 @@ const StandardConverters = {
 			from: (value: number) => value > 0
 		},
 		Percent: {
-			to: (value: number): boolean => {
-				return value > 0;
-			},
-			from: (value: boolean): number => {
-				return value ? 100 : 0;
-			}
+			to: (value: boolean) => (value ? 100 : 0),
+			from: (value: number) => value > 0
 		}
 	},
 	LevelFrom0To255: {
 		Percent: {
 			to: (value: number): number => {
+				if(value === 0) return 0;
+				if(value === 255) return 100;
 				return Math.round((value * 100) / 255);
 			},
 			from: (value: number): number => {
+				if(value === 0) return 0;
+				if(value === 100) return 255;
 				return Math.round((value * 255) / 100);
 			}
 		}
@@ -79,11 +79,11 @@ export namespace Converter {
 	export const Matter = {
 		LevelFrom0To255: {
 			LightingLevel: {
-				from: (value) =>
+				from: (value: number) =>
 					value === 1 ? 0
 					: value === 254 ? 255
 					: value,
-				to: (value) =>
+				to: (value: number) =>
 					value === 0 ? 1
 					: value === 255 ? 254
 					: value
@@ -92,15 +92,21 @@ export namespace Converter {
 		},
 		Percent: {
 			LightingLevel: {
-				from: (value) =>
+				from: (value: number) =>
 					value === 1 ? 0
 					: value === 254 ? 100
 					: Math.round(value / 254 * 100),
-				to: (value) =>
+				to: (value: number) =>
 					value === 0 ? 1
 					: value === 100 ? 254
 					: Math.round(value / 100 * 254)
 			}
+		},
+		Boolean: {
+			LightingLevel: {
+				from: (value: number) => value > 0,
+				to: (value: any) => value ? 254 : 0
+			}
 		}
 	};
 

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

@@ -45,7 +45,9 @@ 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); }
+	export function is(node: ISYNode<any, any, any, any>): node is ChannelNode {
+		return ["BTChannel"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is ChannelNode {
 		return ["BTChannel", "BTMain"].includes(node.nodeDefId);
 	}

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

@@ -60,7 +60,9 @@ 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); }
+	export function is(node: ISYNode<any, any, any, any>): node is MainNode {
+		return ["BTMain"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is MainNode {
 		return ["BTMain"].includes(node.nodeDefId);
 	}

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

@@ -52,7 +52,9 @@ export namespace AlertModuleArmed {
 	export interface Interface extends Omit<InstanceType<typeof AlertModuleArmedNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "AlertModuleArmed";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is AlertModuleArmedNode { return ["AlertModuleArmed"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is AlertModuleArmedNode {
+		return ["AlertModuleArmed"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is AlertModuleArmedNode {
 		return ["AlertModuleArmed", "BallastRelayLampSwitch", "BallastRelayLampSwitch_ADV", "RelayLampSwitch", "RelayLampSwitch_ADV", "RelayLampSwitchLED", "RelayLampSwitchLED_ADV", "RelayLampOnly", "RelayLampOnly_ADV", "KeypadRelay", "KeypadRelay_ADV", "FanLincMotor", "EZRAIN_Output", "AlertModuleSiren", "AlertModuleSiren_ADV"].includes(node.nodeDefId);
 	}

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

@@ -57,7 +57,9 @@ export namespace AlertModuleSiren {
 	export interface Interface extends Omit<InstanceType<typeof AlertModuleSirenNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "AlertModuleSiren" | "AlertModuleSiren_ADV";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is AlertModuleSirenNode { return ["AlertModuleSiren", "AlertModuleSiren_ADV"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is AlertModuleSirenNode {
+		return ["AlertModuleSiren", "AlertModuleSiren_ADV"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is AlertModuleSirenNode {
 		return ["AlertModuleSiren", "AlertModuleSiren_ADV"].includes(node.nodeDefId);
 	}

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

@@ -57,7 +57,9 @@ export namespace BallastRelayLampSwitch {
 	export interface Interface extends Omit<InstanceType<typeof BallastRelayLampSwitchNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "BallastRelayLampSwitch" | "BallastRelayLampSwitch_ADV";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is BallastRelayLampSwitchNode { return ["BallastRelayLampSwitch", "BallastRelayLampSwitch_ADV"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is BallastRelayLampSwitchNode {
+		return ["BallastRelayLampSwitch", "BallastRelayLampSwitch_ADV"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is BallastRelayLampSwitchNode {
 		return ["BallastRelayLampSwitch", "BallastRelayLampSwitch_ADV"].includes(node.nodeDefId);
 	}

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

@@ -49,7 +49,9 @@ export namespace BinaryAlarm {
 	export interface Interface extends Omit<InstanceType<typeof BinaryAlarmNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "BinaryAlarm" | "BinaryAlarm_ADV";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is BinaryAlarmNode { return ["BinaryAlarm", "BinaryAlarm_ADV"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is BinaryAlarmNode {
+		return ["BinaryAlarm", "BinaryAlarm_ADV"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is BinaryAlarmNode {
 		return ["BinaryAlarm", "BallastRelayLampSwitch", "BallastRelayLampSwitch_ADV", "RelayLampSwitch", "RelayLampSwitch_ADV", "RelayLampSwitchLED", "RelayLampSwitchLED_ADV", "KeypadRelay", "KeypadRelay_ADV", "BinaryAlarm_ADV"].includes(node.nodeDefId);
 	}

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

@@ -49,7 +49,9 @@ export namespace BinaryControl {
 	export interface Interface extends Omit<InstanceType<typeof BinaryControlNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "BinaryControl" | "BinaryControl_ADV";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is BinaryControlNode { return ["BinaryControl", "BinaryControl_ADV"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is BinaryControlNode {
+		return ["BinaryControl", "BinaryControl_ADV"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is BinaryControlNode {
 		return ["BinaryControl", "BallastRelayLampSwitch", "BallastRelayLampSwitch_ADV", "RelayLampSwitch", "RelayLampSwitch_ADV", "RelayLampSwitchLED", "RelayLampSwitchLED_ADV", "KeypadRelay", "KeypadRelay_ADV", "BinaryAlarm", "BinaryAlarm_ADV", "BinaryControl_ADV"].includes(node.nodeDefId);
 	}

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

@@ -78,7 +78,9 @@ export namespace DimmerLamp {
 	export interface Interface extends Omit<InstanceType<typeof DimmerLampNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "DimmerLampOnly";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is DimmerLampNode { return ["DimmerLampOnly"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is DimmerLampNode {
+		return ["DimmerLampOnly"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is DimmerLampNode {
 		return ["DimmerLampOnly", "DimmerLampSwitch", "DimmerLampSwitch_ADV", "DimmerLampSwitchLED", "DimmerLampSwitchLED_ADV"].includes(node.nodeDefId);
 	}

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

@@ -81,7 +81,9 @@ export namespace DimmerLampSwitch {
 	export interface Interface extends Omit<InstanceType<typeof DimmerLampSwitchNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "DimmerLampSwitch" | "DimmerLampSwitch_ADV";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is DimmerLampSwitchNode { return ["DimmerLampSwitch", "DimmerLampSwitch_ADV"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is DimmerLampSwitchNode {
+		return ["DimmerLampSwitch", "DimmerLampSwitch_ADV"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is DimmerLampSwitchNode {
 		return ["DimmerLampSwitch", "DimmerLampSwitch_ADV"].includes(node.nodeDefId);
 	}

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

@@ -83,7 +83,9 @@ export namespace DimmerLampSwitchLed {
 	export interface Interface extends Omit<InstanceType<typeof DimmerLampSwitchLedNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "DimmerLampSwitchLED" | "DimmerLampSwitchLED_ADV";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is DimmerLampSwitchLedNode { return ["DimmerLampSwitchLED", "DimmerLampSwitchLED_ADV"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is DimmerLampSwitchLedNode {
+		return ["DimmerLampSwitchLED", "DimmerLampSwitchLED_ADV"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is DimmerLampSwitchLedNode {
 		return ["DimmerLampSwitchLED", "DimmerLampSwitchLED_ADV"].includes(node.nodeDefId);
 	}

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

@@ -77,7 +77,9 @@ export namespace DimmerMotorSwitch {
 	export interface Interface extends Omit<InstanceType<typeof DimmerMotorSwitchNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "DimmerMotorSwitch" | "DimmerMotorSwitch_ADV";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is DimmerMotorSwitchNode { return ["DimmerMotorSwitch", "DimmerMotorSwitch_ADV"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is DimmerMotorSwitchNode {
+		return ["DimmerMotorSwitch", "DimmerMotorSwitch_ADV"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is DimmerMotorSwitchNode {
 		return ["DimmerMotorSwitch", "DimmerMotorSwitch_ADV"].includes(node.nodeDefId);
 	}

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

@@ -43,7 +43,9 @@ export namespace DimmerSwitch {
 	export interface Interface extends Omit<InstanceType<typeof DimmerSwitchNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "DimmerSwitchOnly" | "DimmerSwitchOnly_ADV";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is DimmerSwitchNode { return ["DimmerSwitchOnly", "DimmerSwitchOnly_ADV"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is DimmerSwitchNode {
+		return ["DimmerSwitchOnly", "DimmerSwitchOnly_ADV"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is DimmerSwitchNode {
 		return ["DimmerSwitchOnly", "DimmerLampSwitch", "DimmerLampSwitch_ADV", "DimmerLampSwitchLED", "DimmerLampSwitchLED_ADV", "DimmerSwitchOnly_ADV"].includes(node.nodeDefId);
 	}

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

@@ -48,7 +48,9 @@ export namespace DoorLock {
 	export interface Interface extends Omit<InstanceType<typeof DoorLockNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "DoorLock";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is DoorLockNode { return ["DoorLock"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is DoorLockNode {
+		return ["DoorLock"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is DoorLockNode {
 		return ["DoorLock", "RelayLampSwitch", "RelayLampSwitch_ADV", "RelayLampSwitchLED", "RelayLampSwitchLED_ADV", "KeypadRelay", "KeypadRelay_ADV", "FanLincMotor"].includes(node.nodeDefId);
 	}

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

@@ -45,7 +45,9 @@ export namespace Ezio2x4Input {
 	export interface Interface extends Omit<InstanceType<typeof Ezio2x4InputNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "EZIO2x4_Input" | "EZIO2x4_Input_ADV";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is Ezio2x4InputNode { return ["EZIO2x4_Input", "EZIO2x4_Input_ADV"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is Ezio2x4InputNode {
+		return ["EZIO2x4_Input", "EZIO2x4_Input_ADV"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is Ezio2x4InputNode {
 		return ["EZIO2x4_Input", "BallastRelayLampSwitch", "BallastRelayLampSwitch_ADV", "RelayLampSwitch", "RelayLampSwitch_ADV", "RelayLampSwitchLED", "RelayLampSwitchLED_ADV", "KeypadRelay", "KeypadRelay_ADV", "KeypadButton", "KeypadButton_ADV", "EZRAIN_Input", "EZRAIN_Input_ADV", "EZIO2x4_Input_ADV"].includes(node.nodeDefId);
 	}

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

@@ -50,7 +50,9 @@ export namespace Ezio2x4Output {
 	export interface Interface extends Omit<InstanceType<typeof Ezio2x4OutputNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "EZIO2x4_Output";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is Ezio2x4OutputNode { return ["EZIO2x4_Output"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is Ezio2x4OutputNode {
+		return ["EZIO2x4_Output"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is Ezio2x4OutputNode {
 		return ["EZIO2x4_Output", "BallastRelayLampSwitch", "BallastRelayLampSwitch_ADV", "RelayLampSwitch", "RelayLampSwitch_ADV", "RelayLampSwitchLED", "RelayLampSwitchLED_ADV", "RelayLampOnly", "RelayLampOnly_ADV", "KeypadRelay", "KeypadRelay_ADV", "FanLincMotor", "EZRAIN_Output"].includes(node.nodeDefId);
 	}

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

@@ -45,7 +45,9 @@ export namespace EzrainInput {
 	export interface Interface extends Omit<InstanceType<typeof EzrainInputNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "EZRAIN_Input" | "EZRAIN_Input_ADV";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is EzrainInputNode { return ["EZRAIN_Input", "EZRAIN_Input_ADV"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is EzrainInputNode {
+		return ["EZRAIN_Input", "EZRAIN_Input_ADV"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is EzrainInputNode {
 		return ["EZRAIN_Input", "EZRAIN_Input_ADV"].includes(node.nodeDefId);
 	}

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

@@ -52,7 +52,9 @@ export namespace EzrainOutput {
 	export interface Interface extends Omit<InstanceType<typeof EzrainOutputNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "EZRAIN_Output";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is EzrainOutputNode { return ["EZRAIN_Output"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is EzrainOutputNode {
+		return ["EZRAIN_Output"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is EzrainOutputNode {
 		return ["EZRAIN_Output", "BallastRelayLampSwitch", "BallastRelayLampSwitch_ADV", "RelayLampSwitch", "RelayLampSwitch_ADV", "RelayLampSwitchLED", "RelayLampSwitchLED_ADV", "RelayLampOnly", "RelayLampOnly_ADV", "KeypadRelay", "KeypadRelay_ADV", "FanLincMotor"].includes(node.nodeDefId);
 	}

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

@@ -56,7 +56,9 @@ export namespace FanLincMotor {
 	export interface Interface extends Omit<InstanceType<typeof FanLincMotorNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "FanLincMotor";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is FanLincMotorNode { return ["FanLincMotor"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is FanLincMotorNode {
+		return ["FanLincMotor"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is FanLincMotorNode {
 		return ["FanLincMotor"].includes(node.nodeDefId);
 	}

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

@@ -96,7 +96,9 @@ export namespace I3KeypadFlags {
 	export interface Interface extends Omit<InstanceType<typeof I3KeypadFlagsNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "I3KeypadFlags";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is I3KeypadFlagsNode { return ["I3KeypadFlags"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is I3KeypadFlagsNode {
+		return ["I3KeypadFlags"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is I3KeypadFlagsNode {
 		return ["I3KeypadFlags"].includes(node.nodeDefId);
 	}

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

@@ -84,7 +84,9 @@ export namespace I3PaddleFlags {
 	export interface Interface extends Omit<InstanceType<typeof I3PaddleFlagsNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "I3PaddleFlags";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is I3PaddleFlagsNode { return ["I3PaddleFlags"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is I3PaddleFlagsNode {
+		return ["I3PaddleFlags"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is I3PaddleFlagsNode {
 		return ["I3PaddleFlags", "I3KeypadFlags"].includes(node.nodeDefId);
 	}

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

@@ -52,7 +52,9 @@ export namespace ImeterSolo {
 	export interface Interface extends Omit<InstanceType<typeof ImeterSoloNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "IMETER_SOLO";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is ImeterSoloNode { return ["IMETER_SOLO"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is ImeterSoloNode {
+		return ["IMETER_SOLO"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is ImeterSoloNode {
 		return ["IMETER_SOLO"].includes(node.nodeDefId);
 	}

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

@@ -42,7 +42,9 @@ export namespace IrLincTx {
 	export interface Interface extends Omit<InstanceType<typeof IrLincTxNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "IRLincTx";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is IrLincTxNode { return ["IRLincTx"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is IrLincTxNode {
+		return ["IRLincTx"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is IrLincTxNode {
 		return ["IRLincTx", "Thermostat", "TempLinc", "DimmerMotorSwitch", "DimmerMotorSwitch_ADV", "DimmerLampSwitch", "DimmerLampSwitch_ADV", "DimmerLampSwitchLED", "DimmerLampSwitchLED_ADV", "DimmerLampOnly", "KeypadDimmer", "KeypadDimmer_ADV", "BallastRelayLampSwitch", "BallastRelayLampSwitch_ADV", "RelayLampSwitch", "RelayLampSwitch_ADV", "RelayLampSwitchLED", "RelayLampSwitchLED_ADV", "RelaySwitchOnlyPlusQuery", "RelaySwitchOnlyPlusQuery_ADV", "RelaySwitchOnly", "RelaySwitchOnly_ADV", "RelayLampOnly", "RelayLampOnly_ADV", "KeypadRelay", "KeypadRelay_ADV"].includes(node.nodeDefId);
 	}

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

@@ -49,7 +49,9 @@ export namespace KeypadButton {
 	export interface Interface extends Omit<InstanceType<typeof KeypadButtonNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "KeypadButton" | "KeypadButton_ADV";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is KeypadButtonNode { return ["KeypadButton", "KeypadButton_ADV"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is KeypadButtonNode {
+		return ["KeypadButton", "KeypadButton_ADV"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is KeypadButtonNode {
 		return ["KeypadButton", "KeypadRelay", "KeypadRelay_ADV", "KeypadButton_ADV"].includes(node.nodeDefId);
 	}

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

@@ -36,7 +36,7 @@ export class KeypadDimmerNode extends Base<Drivers, Commands> implements KeypadD
 		WDU: this.writeChanges
 	};
 	static override nodeDefId = "KeypadDimmer";
-	static override implements = ["KeypadDimmer", "RemoteLinc2", "RemoteLinc2_ADV", "IRLincTx", "SirenAlert", "SirenArm"];
+	static override implements = ["KeypadDimmer", "RelaySwitchOnlyPlusQuery", "RelaySwitchOnlyPlusQuery_ADV", "RelaySwitchOnly", "RelaySwitchOnly_ADV", "RemoteLinc2", "RemoteLinc2_ADV", "IRLincTx", "SirenAlert", "SirenArm"];
 	declare readonly nodeDefId: "KeypadDimmer" | "KeypadDimmer_ADV";
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
@@ -81,7 +81,9 @@ export namespace KeypadDimmer {
 	export interface Interface extends Omit<InstanceType<typeof KeypadDimmerNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "KeypadDimmer" | "KeypadDimmer_ADV";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is KeypadDimmerNode { return ["KeypadDimmer", "KeypadDimmer_ADV"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is KeypadDimmerNode {
+		return ["KeypadDimmer", "KeypadDimmer_ADV"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is KeypadDimmerNode {
 		return ["KeypadDimmer", "KeypadDimmer_ADV"].includes(node.nodeDefId);
 	}