isy-nodejs 1.0.2-alpha.4 → 1.0.2-alpha.6

package/src/CodeGeneration/NodeClassFactory.ts

@@ -6,7 +6,7 @@ import { UnitOfMeasure } from '../Definitions/Global/UOM.js';
 import { Family } from '../Definitions/index.js';
 import { CommandDefinition, DataTypeDefinition, DriverDefinition, NodeClassDefinition, ParameterDefinition } from '../Model/ClassDefinition.js';
 import { EnumDefinitionMap } from '../Model/EnumDefinition.js';
-import { CodeFactory } from './NodeFactory.js';
+import { CodeFactory } from './CodeFactory.js';
 
 // #region Type aliases (1)
 
@@ -69,7 +69,7 @@ export class NodeClassFactory extends CodeFactory {
 			});
 	}
 
-	N;
+
 
 	public createNodeClass<T extends Family>(nodeClassDef: NodeClassDefinition<T>) {
 		let path = `${NodeClassFactory.basePath}/${Family[nodeClassDef.family]}/Generated/${nodeClassDef.name}.ts`;
@@ -95,7 +95,7 @@ export class NodeClassFactory extends CodeFactory {
 				factory.createStringLiteral('../../../Model/NodeInfo.js'),
 				undefined
 			),
-			this.createImportDeclaration('../../../ISY.js', ['ISY']),
+			NodeClassFactory.instance.createImportDeclaration('../../../ISY.js', ['ISY']),
 			factory.createImportDeclaration(
 				undefined,
 				factory.createImportClause(true, undefined, factory.createNamedImports([factory.createImportSpecifier(false, undefined, factory.createIdentifier('ISYNode'))])),
@@ -203,16 +203,16 @@ export class NodeClassFactory extends CodeFactory {
 						undefined,
 						factory.createStringLiteral(nodeClassDef.id)
 					),
-					this.createPropertyDeclaration(
+					NodeClassFactory.instance.createPropertyDeclaration(
 						'implements',
 						factory.createArrayLiteralExpression(
 							nodeClassDef.implementedBy ?
-								[this.createStringLiteral(nodeClassDef.id)].concat(
+								[NodeClassFactory.instance.createStringLiteral(nodeClassDef.id)].concat(
 									!nodeClassDef.implements || nodeClassDef.implements.length == 0 ? [] : nodeClassDef.implements?.map((p) => factory.createStringLiteral(p))
 								)
-							:	[this.createStringLiteral(nodeClassDef.id)]
+							:	[NodeClassFactory.instance.createStringLiteral(nodeClassDef.id)]
 						),
-						this.createModifiers(ts.ModifierFlags.Static | ts.ModifierFlags.Override)
+						NodeClassFactory.instance.createModifiers(ts.ModifierFlags.Static | ts.ModifierFlags.Override)
 					),
 					factory.createPropertyDeclaration(
 						[factory.createToken(ts.SyntaxKind.DeclareKeyword), factory.createToken(ts.SyntaxKind.ReadonlyKeyword)],
@@ -220,11 +220,11 @@ export class NodeClassFactory extends CodeFactory {
 						undefined,
 						nodeClassDef.equivalents ?
 							NodeClassFactory.instance.createUnionTypeNode(
-								...[this.createLiteralTypeNode(nodeClassDef.id)].concat(
+								...[NodeClassFactory.instance.createLiteralTypeNode(nodeClassDef.id)].concat(
 									!nodeClassDef.equivalents || nodeClassDef.equivalents.length == 0 ? [] : nodeClassDef.equivalents?.map((p) => factory.createLiteralTypeNode(factory.createStringLiteral(p)))
 								)
 							)
-						:	this.createLiteralTypeNode(nodeClassDef.id),
+						:	NodeClassFactory.instance.createLiteralTypeNode(nodeClassDef.id),
 						undefined
 					),
 					factory.createConstructorDeclaration(
@@ -250,13 +250,13 @@ export class NodeClassFactory extends CodeFactory {
 						factory.createBlock(
 							[
 								factory.createExpressionStatement(factory.createCallExpression(factory.createSuper(), undefined, [factory.createIdentifier('isy'), factory.createIdentifier('nodeInfo')])),
-								...Object.values(nodeClassDef.drivers).map(createDriverInitializationStatement)
+								...Object.values(nodeClassDef.drivers).map(p => NodeClassFactory.instance.createDriverInitializationStatement(p))
 							],
 							true
 						)
 					),
-					...Object.values(nodeClassDef.commands).map(createCommandMethodDeclaration),
-					...Object.values(nodeClassDef.drivers).map(createDriverGetDeclaration)
+					...Object.values(nodeClassDef.commands).map(p => NodeClassFactory.instance.createCommandMethodDeclaration(p)),
+					...Object.values(nodeClassDef.drivers).map(p => NodeClassFactory.instance.createDriverGetDeclaration(p))
 				]
 			),
 			factory.createExpressionStatement(
@@ -286,7 +286,7 @@ export class NodeClassFactory extends CodeFactory {
 						[
 							factory.createHeritageClause(ts.SyntaxKind.ExtendsKeyword, [
 								factory.createExpressionWithTypeArguments(factory.createIdentifier('Omit'), [
-									this.createTypeReferenceNode('InstanceType', this.factory.createTypeQueryNode(factory.createIdentifier(`${nodeClassDef.name}Node`))),
+									NodeClassFactory.instance.createTypeReferenceNode('InstanceType', NodeClassFactory.instance.factory.createTypeQueryNode(factory.createIdentifier(`${nodeClassDef.name}Node`))),
 									factory.createTypeOperatorNode(
 										ts.SyntaxKind.KeyOfKeyword,
 										factory.createTypeReferenceNode(factory.createIdentifier('ISYDeviceNode'), [
@@ -305,12 +305,12 @@ export class NodeClassFactory extends CodeFactory {
 								factory.createIdentifier('nodeDefId'),
 								undefined,
 								nodeClassDef.equivalents ?
-									this.createUnionTypeNode(
-										...[this.createLiteralTypeNode(nodeClassDef.id)].concat(
+									NodeClassFactory.instance.createUnionTypeNode(
+										...[NodeClassFactory.instance.createLiteralTypeNode(nodeClassDef.id)].concat(
 											!nodeClassDef.equivalents || nodeClassDef.equivalents.length == 0 ? [] : nodeClassDef.equivalents?.map((p) => factory.createLiteralTypeNode(factory.createStringLiteral(p)))
 										)
 									)
-								:	this.createLiteralTypeNode(nodeClassDef.id)
+								:	NodeClassFactory.instance.createLiteralTypeNode(nodeClassDef.id)
 							)
 						]
 					),
@@ -336,16 +336,16 @@ export class NodeClassFactory extends CodeFactory {
 							)
 						],
 						factory.createTypePredicateNode(undefined, factory.createIdentifier('node'), factory.createTypeReferenceNode(factory.createIdentifier(`${nodeClassDef.name}Node`), undefined)),
-						this.createBlock(
-							this.createReturnStatement(
+						NodeClassFactory.instance.createBlock(
+							NodeClassFactory.instance.createReturnStatement(
 								factory.createCallExpression(
 									factory.createPropertyAccessExpression(
 										factory.createArrayLiteralExpression(
 											nodeClassDef.equivalents ?
-												[this.createStringLiteral(nodeClassDef.id)].concat(
+												[NodeClassFactory.instance.createStringLiteral(nodeClassDef.id)].concat(
 													!nodeClassDef.equivalents || nodeClassDef.equivalents.length == 0 ? [] : nodeClassDef.equivalents?.map((p) => factory.createStringLiteral(p))
 												)
-											:	[this.createStringLiteral(nodeClassDef.id)]
+											:	[NodeClassFactory.instance.createStringLiteral(nodeClassDef.id)]
 										),
 										'includes'
 									),
@@ -366,17 +366,18 @@ export class NodeClassFactory extends CodeFactory {
 								undefined,
 								factory.createIdentifier('node'),
 								undefined,
-								factory.createTypeReferenceNode(factory.createIdentifier('ISYNode'), [
-									factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
-									factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
-									factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
-									factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
-								]),
+								NodeClassFactory.instance.createTypeReferenceNode(
+									'ISYNode',
+									NodeClassFactory.instance.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+									NodeClassFactory.instance.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+									NodeClassFactory.instance.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+									NodeClassFactory.instance.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
+								),
 								undefined
 							)
 						],
 						factory.createTypePredicateNode(undefined, factory.createIdentifier('node'), factory.createTypeReferenceNode(factory.createIdentifier(`${nodeClassDef.name}Node`), undefined)),
-						this.createBlock(
+						NodeClassFactory.instance.createBlock(
 							true,
 
 							factory.createReturnStatement(
@@ -384,10 +385,10 @@ export class NodeClassFactory extends CodeFactory {
 									factory.createPropertyAccessExpression(
 										factory.createArrayLiteralExpression(
 											nodeClassDef.implementedBy ?
-												[this.createStringLiteral(nodeClassDef.id)].concat(
+												[NodeClassFactory.instance.createStringLiteral(nodeClassDef.id)].concat(
 													!nodeClassDef.implementedBy || nodeClassDef.implementedBy.length == 0 ? [] : nodeClassDef.implementedBy?.map((p) => factory.createStringLiteral(p))
 												)
-											:	[this.createStringLiteral(nodeClassDef.id)]
+											:	[NodeClassFactory.instance.createStringLiteral(nodeClassDef.id)]
 										),
 										'includes'
 									),
@@ -441,13 +442,13 @@ export class NodeClassFactory extends CodeFactory {
 						[factory.createToken(ts.SyntaxKind.ExportKeyword)],
 						factory.createIdentifier('Commands'),
 						undefined,
-						factory.createTypeLiteralNode([...Object.values(nodeClassDef.commands).map(createCommandSignature)])
+						factory.createTypeLiteralNode([...Object.values(nodeClassDef.commands).map(NodeClassFactory.instance.createCommandSignature)])
 					),
 					factory.createTypeAliasDeclaration(
 						[factory.createToken(ts.SyntaxKind.ExportKeyword)],
 						factory.createIdentifier('Drivers'),
 						undefined,
-						factory.createTypeLiteralNode([...Object.values(nodeClassDef.drivers).map(createDriverSignature)])
+						factory.createTypeLiteralNode([...Object.values(nodeClassDef.drivers).map(NodeClassFactory.instance.createDriverSignature)])
 					)
 				]),
 				ts.NodeFlags.Namespace
@@ -494,163 +495,237 @@ export class NodeClassFactory extends CodeFactory {
 		let modules = [];
 		for (const family of NodeClassDefinition.Map.keys()) {
 			var t = this.generateClassesForFamily(family);
-			modules.push(buildClassIndex(family, t));
+			modules.push(NodeClassFactory.buildClassIndex(family, t));
 		}
 		return modules;
 	}
 
 	public static generateClassesForFamily<T extends Family>(family: T): GeneratedNodeClass<T>[] {
-		return this.buildNodeClasses<T>(NodeClassDefinition.Map.get(family) as { [x: string]: NodeClassDefinition<T> });
+		return NodeClassFactory.buildNodeClasses<T>(NodeClassDefinition.Map.get(family) as { [x: string]: NodeClassDefinition<T> });
 	}
 
-	// #endregion Public Static Methods (4)
-}
+	// #region Functions (12)
 
-// #endregion Classes (1)
+	static buildClassIndex<T extends Family>(family: T, classes: GeneratedNodeClass<T>[]) {
+		return {
+			family,
+			path: `/${Family[family]}/Generated/index.ts`,
+			statements: [...classes.map((p) => factory.createExportDeclaration(undefined, false, undefined, factory.createStringLiteral(`./${p.name}.js`), undefined))]
+		};
+	}
 
-// #region Functions (12)
+	createCommandArguments(def: CommandDefinition)
+	{
+		 let c = [
+				factory.createStringLiteral(def.id)];
+		let n = [];
+		let r = [];
 
-function buildClassIndex<T extends Family>(family: T, classes: GeneratedNodeClass<T>[]) {
-	return {
-		family,
-		path: `/${Family[family]}/Generated/index.ts`,
-		statements: [...classes.map((p) => factory.createExportDeclaration(undefined, false, undefined, factory.createStringLiteral(`./${p.name}.js`), undefined))]
-	};
-}
+		if(def.parameters)
+		{
+			for(let p in def.parameters)
+			{
+				let p2 = def.parameters[p];
+				if(!p2?.id || p2.id == 'value')
+				{
+					n.push(factory.createIdentifier(p2.name ?? 'value'))
+				}
+				else
+				{
+					r.push(p2);
+				}
+			}
+		}
+		let fnl = [...c,...n,
 
-function createCommandMethodDeclaration(def: CommandDefinition) {
-	return factory.createMethodDeclaration(
-		[factory.createToken(ts.SyntaxKind.AsyncKeyword)],
-		undefined,
-		factory.createIdentifier(def.name),
-		undefined,
-		undefined,
-
-		def.parameters ? Object.values(def.parameters).map(createParameterDeclarationSignature) : undefined,
-		undefined,
-		NodeClassFactory.instance.createBlock(
-
-				factory.createReturnStatement(
-					factory.createCallExpression(factory.createPropertyAccessExpression(factory.createThis(), factory.createIdentifier('sendCommand')), undefined, [
-						factory.createStringLiteral(def.id),
-						...(def.parameters ?
-							[
-								factory.createObjectLiteralExpression(
-									[...Object.values(def.parameters).map((p) => factory.createPropertyAssignment(factory.createIdentifier(p.id ?? 'value'), factory.createIdentifier(p.name ?? 'value')))],
-									false
-								)
-							]
-						:	[])
-					])
-				)
 
-		)
-	);
-}
+						...(r.length > 0 ? [factory.createObjectLiteralExpression(
+							r.map((q) => factory.createPropertyAssignment(factory.createIdentifier(q.id ?? 'value'), factory.createIdentifier(q.name ?? 'value'))),
+							false
+						)] : [])
 
-function createCommandParameterType(def: DataTypeDefinition, parent: ParameterDefinition): ts.TypeNode {
-	if (def.enum) {
-		{
-			if (EnumDefinitionMap.has(parent.classDef.family)) {
-				var enumDef = EnumDefinitionMap.get(parent.classDef.family)[def.indexId];
 
-				// ?? EnumDefinitionMap[Family.Global]?[def.indexId]
-				if (enumDef) {
-					return factory.createTypeReferenceNode(factory.createQualifiedName(factory.createIdentifier(Family[parent.classDef.family]), factory.createIdentifier(enumDef.name)), undefined);
+			];
+		return fnl.length > 0 ? fnl : undefined;
+	}
+
+	createCommandMethodDeclaration(def: CommandDefinition) {
+		return factory.createMethodDeclaration(
+			[factory.createToken(ts.SyntaxKind.AsyncKeyword)],
+			undefined,
+			factory.createIdentifier(def.name),
+			undefined,
+			undefined,
+
+			def.parameters ? Object.values(def.parameters).map(NodeClassFactory.instance.createParameterDeclarationSignature.bind(this)) : undefined,
+			undefined,
+			factory.createBlock(
+				[factory.createReturnStatement(
+					factory.createCallExpression(factory.createPropertyAccessExpression(factory.createThis(), factory.createIdentifier('sendCommand')), undefined,NodeClassFactory.instance.createCommandArguments(def))
+				)]
+			)
+		);
+	}
+
+	createCommandParameterType(def: DataTypeDefinition, parent: ParameterDefinition): ts.TypeNode {
+		if (def.enum) {
+			{
+				if (EnumDefinitionMap.has(parent.classDef.family)) {
+					var enumDef = EnumDefinitionMap.get(parent.classDef.family)[def.indexId];
+
+					// ?? EnumDefinitionMap[Family.Global]?[def.indexId]
+					if (enumDef) {
+						return factory.createTypeReferenceNode(factory.createQualifiedName(factory.createIdentifier(Family[parent.classDef.family]), factory.createIdentifier(enumDef.name)), undefined);
+					}
 				}
-			}
 
-			if (def.values) {
-				return NodeClassFactory.instance.createUnionTypeNode(...Object.keys(def.values).map((p) => factory.createLiteralTypeNode(factory.createNumericLiteral(p))));
-			}
+				if (def.values) {
+					return NodeClassFactory.instance.createUnionTypeNode(...Object.keys(def.values).map((p) => factory.createLiteralTypeNode(factory.createNumericLiteral(p))));
+				}
 
-			//   return NodeClassFactory.instance.createUnionTypeNode(...
-			//     Object.values(def.values).map((p) => factory.createTypeReferenceNode(
-			//   factory.createQualifiedName(
-			//     factory.createIdentifier("UnitOfMeasure"),
-			//     factory.createIdentifier(UnitOfMeasure)
-			//   ),
-			//   undefined
-			// )))
+				//   return NodeClassFactory.instance.createUnionTypeNode(...
+				//     Object.values(def.values).map((p) => factory.createTypeReferenceNode(
+				//   factory.createQualifiedName(
+				//     factory.createIdentifier("UnitOfMeasure"),
+				//     factory.createIdentifier(UnitOfMeasure)
+				//   ),
+				//   undefined
+				// )))
+			}
 		}
+		return factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
 	}
-	return factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
-}
 
-function createCommandSignature(def: CommandDefinition) {
-	return factory.createPropertySignature(
-		undefined,
-		factory.createIdentifier(def.id),
-		undefined,
-		factory.createIntersectionTypeNode([
-			factory.createParenthesizedType(
-				factory.createFunctionTypeNode(
-					undefined,
-					def.parameters ? Object.values(def.parameters).map(createParameterSignature) : [],
+	createCommandSignature(def: CommandDefinition) {
+		const that = this;
+		return factory.createPropertySignature(
+			undefined,
+			factory.createIdentifier(def.id),
+			undefined,
+			factory.createIntersectionTypeNode([
+				factory.createParenthesizedType(
+					factory.createFunctionTypeNode(
+						undefined,
+						def.parameters ? Object.values(def.parameters).map(p => NodeClassFactory.instance.createParameterSignature(p)) : [],
 
-					factory.createTypeReferenceNode(factory.createIdentifier('Promise'), [factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword)])
-				)
-			),
-			factory.createTypeLiteralNode([
-				factory.createPropertySignature(undefined, factory.createIdentifier('label'), undefined, factory.createLiteralTypeNode(factory.createStringLiteral(def.label))),
-				factory.createPropertySignature(undefined, factory.createIdentifier('name'), undefined, factory.createLiteralTypeNode(factory.createStringLiteral(def.name)))
+						factory.createTypeReferenceNode(factory.createIdentifier('Promise'), [factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword)])
+					)
+				),
+				factory.createTypeLiteralNode([
+					factory.createPropertySignature(undefined, factory.createIdentifier('label'), undefined, factory.createLiteralTypeNode(factory.createStringLiteral(def.label))),
+					factory.createPropertySignature(undefined, factory.createIdentifier('name'), undefined, factory.createLiteralTypeNode(factory.createStringLiteral(def.name)))
+				])
 			])
-		])
-	);
-}
+		);
+	}
 
-function createDriverGetDeclaration(def: DriverDefinition) {
-	return factory.createGetAccessorDeclaration(
-		[factory.createToken(ts.SyntaxKind.PublicKeyword)],
-		factory.createIdentifier(def.name),
-		[],
-		NodeClassFactory.instance.createUnionTypeNode(...Object.values(def.dataType).map((p) => createDriverPropertyReturnType(p, def))),
-		factory.createBlock(
-			[
-				factory.createReturnStatement(
-					factory.createPropertyAccessChain(
-						factory.createPropertyAccessExpression(factory.createPropertyAccessExpression(factory.createThis(), factory.createIdentifier('drivers')), factory.createIdentifier(def.id)),
-						factory.createToken(ts.SyntaxKind.QuestionDotToken),
-						factory.createIdentifier('value')
+	createDriverGetDeclaration(def: DriverDefinition) {
+		return factory.createGetAccessorDeclaration(
+			[factory.createToken(ts.SyntaxKind.PublicKeyword)],
+			factory.createIdentifier(def.name),
+			[],
+			NodeClassFactory.instance.createUnionTypeNode(...Object.values(def.dataType).map((p) => NodeClassFactory.instance.createDriverPropertyReturnType(p, def))),
+			factory.createBlock(
+				[
+					factory.createReturnStatement(
+						factory.createPropertyAccessChain(
+							factory.createPropertyAccessExpression(factory.createPropertyAccessExpression(factory.createThis(), factory.createIdentifier('drivers')), factory.createIdentifier(def.id)),
+							factory.createToken(ts.SyntaxKind.QuestionDotToken),
+							factory.createIdentifier('value')
+						)
 					)
-				)
-			],
-			true
-		)
-	);
-}
+				],
+				true
+			)
+		);
+	}
+
+	createDriverInitializationStatement(def: DriverDefinition): ts.Statement {
+		return factory.createExpressionStatement(
+			factory.createBinaryExpression(
+				factory.createPropertyAccessExpression(factory.createPropertyAccessExpression(factory.createThis(), factory.createIdentifier('drivers')), factory.createIdentifier(def.id)),
+				factory.createToken(ts.SyntaxKind.EqualsToken),
+				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.createObjectLiteralExpression(
+						[
+							factory.createPropertyAssignment(
+								factory.createIdentifier('uom'),
+								factory.createPropertyAccessExpression(factory.createIdentifier('UnitOfMeasure'), factory.createIdentifier(UnitOfMeasure[parseInt(Object.keys(def.dataType)[0])] ?? 'Unknown'))
+							),
+							factory.createPropertyAssignment(factory.createIdentifier('label'), factory.createStringLiteral(def.label)),
+							factory.createPropertyAssignment(factory.createIdentifier('name'), factory.createStringLiteral(def.name))
+						],
+						false
+					)
+				])
+			)
+		);
+	}
 
-function createDriverInitializationStatement(def: DriverDefinition): ts.Statement {
-	return factory.createExpressionStatement(
-		factory.createBinaryExpression(
-			factory.createPropertyAccessExpression(factory.createPropertyAccessExpression(factory.createThis(), factory.createIdentifier('drivers')), factory.createIdentifier(def.id)),
-			factory.createToken(ts.SyntaxKind.EqualsToken),
-			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)
+	createDriverPropertyReturnType(def: DataTypeDefinition, parent: DriverDefinition): ts.TypeNode {
+		if (def.enum) {
+			{
+				if (EnumDefinitionMap.has(parent.classDef.family)) {
+					var enumDef = EnumDefinitionMap.get(parent.classDef.family)[def.indexId];
+
+					// ?? EnumDefinitionMap[Family.Global]?[def.indexId]
+					if (enumDef) {
+						return factory.createTypeReferenceNode(factory.createQualifiedName(factory.createIdentifier(Family[parent.classDef.family]), factory.createIdentifier(enumDef.name)), undefined);
+					}
+				}
+				if (def.values) {
+					return NodeClassFactory.instance.createUnionTypeNode(...Object.keys(def.values).map((p) => factory.createLiteralTypeNode(factory.createNumericLiteral(p))));
+				}
+
+				//   return NodeClassFactory.instance.createUnionTypeNode(...
+				//     Object.values(def.values).map((p) => factory.createTypeReferenceNode(
+				//   factory.createQualifiedName(
+				//     factory.createIdentifier("UnitOfMeasure"),
+				//     factory.createIdentifier(UnitOfMeasure)
+				//   ),
+				//   undefined
+				// )))
+			}
+		}
+		return factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
+	}
+
+	createDriverSignature(def: DriverDefinition) {
+		return factory.createPropertySignature(
+			undefined,
+			factory.createIdentifier(def.id),
+			undefined,
+			factory.createTypeLiteralNode([
+				factory.createPropertySignature(
+					undefined,
+					factory.createIdentifier('uom'),
+					undefined,
+					def.dataType ?
+						NodeClassFactory.instance.createUnionTypeNode(...Object.values(def.dataType).map((p) => NodeClassFactory.instance.createTypeNodeForUOM(p.uom)))
+					:	factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)
 				),
-				factory.createObjectLiteralExpression(
-					[
-						factory.createPropertyAssignment(
-							factory.createIdentifier('uom'),
-							factory.createPropertyAccessExpression(factory.createIdentifier('UnitOfMeasure'), factory.createIdentifier(UnitOfMeasure[parseInt(Object.keys(def.dataType)[0])] ?? 'Unknown'))
-						),
-						factory.createPropertyAssignment(factory.createIdentifier('label'), factory.createStringLiteral(def.label)),
-						factory.createPropertyAssignment(factory.createIdentifier('name'), factory.createStringLiteral(def.name))
-					],
-					false
-				)
+				factory.createPropertySignature(
+					undefined,
+					factory.createIdentifier('value'),
+					undefined,
+					def.dataType ?
+						NodeClassFactory.instance.createUnionTypeNode(...Object.values(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))),
+				factory.createPropertySignature(undefined, factory.createIdentifier('name'), undefined, factory.createLiteralTypeNode(factory.createStringLiteral(def.name)))
 			])
-		)
-	);
-}
+		);
+	}
 
-function createDriverPropertyReturnType(def: DataTypeDefinition, parent: DriverDefinition): ts.TypeNode {
-	if (def.enum) {
-		{
+	createDriverSignatureReturnType(def: DataTypeDefinition, parent: DriverDefinition): ts.TypeNode {
+		if (def.enum) {
 			if (EnumDefinitionMap.has(parent.classDef.family)) {
 				var enumDef = EnumDefinitionMap.get(parent.classDef.family)[def.indexId];
 
@@ -662,93 +737,42 @@ function createDriverPropertyReturnType(def: DataTypeDefinition, parent: DriverD
 			if (def.values) {
 				return NodeClassFactory.instance.createUnionTypeNode(...Object.keys(def.values).map((p) => factory.createLiteralTypeNode(factory.createNumericLiteral(p))));
 			}
-
-			//   return NodeClassFactory.instance.createUnionTypeNode(...
-			//     Object.values(def.values).map((p) => factory.createTypeReferenceNode(
-			//   factory.createQualifiedName(
-			//     factory.createIdentifier("UnitOfMeasure"),
-			//     factory.createIdentifier(UnitOfMeasure)
-			//   ),
-			//   undefined
-			// )))
 		}
+		return factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
 	}
-	return factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
-}
-
-function createDriverSignature(def: DriverDefinition) {
-	return factory.createPropertySignature(
-		undefined,
-		factory.createIdentifier(def.id),
-		undefined,
-		factory.createTypeLiteralNode([
-			factory.createPropertySignature(
-				undefined,
-				factory.createIdentifier('uom'),
-				undefined,
-				def.dataType ?
-					NodeClassFactory.instance.createUnionTypeNode(...Object.values(def.dataType).map((p) => createTypeNodeForUOM(p.uom)))
-				:	factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)
-			),
-			factory.createPropertySignature(
-				undefined,
-				factory.createIdentifier('value'),
-				undefined,
-				def.dataType ?
-					NodeClassFactory.instance.createUnionTypeNode(...Object.values(def.dataType).map((p) => createDriverSignatureReturnType(p, def)))
-				:	factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)
-			),
-			factory.createPropertySignature(undefined, factory.createIdentifier('label'), undefined, factory.createLiteralTypeNode(factory.createStringLiteral(def.label))),
-			factory.createPropertySignature(undefined, factory.createIdentifier('name'), undefined, factory.createLiteralTypeNode(factory.createStringLiteral(def.name)))
-		])
-	);
-}
-
-function createDriverSignatureReturnType(def: DataTypeDefinition, parent: DriverDefinition): ts.TypeNode {
-	if (def.enum) {
-		if (EnumDefinitionMap.has(parent.classDef.family)) {
-			var enumDef = EnumDefinitionMap.get(parent.classDef.family)[def.indexId];
 
-			// ?? EnumDefinitionMap[Family.Global]?[def.indexId]
-			if (enumDef) {
-				return factory.createTypeReferenceNode(factory.createQualifiedName(factory.createIdentifier(Family[parent.classDef.family]), factory.createIdentifier(enumDef.name)), undefined);
-			}
-		}
-		if (def.values) {
-			return NodeClassFactory.instance.createUnionTypeNode(...Object.keys(def.values).map((p) => factory.createLiteralTypeNode(factory.createNumericLiteral(p))));
-		}
+	createParameterDeclarationSignature(def: ParameterDefinition) {
+		return factory.createParameterDeclaration(
+			undefined,
+			undefined,
+			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)))
+			:	factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
+			undefined
+		);
 	}
-	return factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
-}
 
-function createParameterDeclarationSignature(def: ParameterDefinition) {
-	return factory.createParameterDeclaration(
-		undefined,
-		undefined,
-		factory.createIdentifier(def.name ?? 'value'),
-		def.optional ? factory.createToken(ts.SyntaxKind.QuestionToken) : undefined,
-		def.dataType ?
-			NodeClassFactory.instance.createUnionTypeNode(...Object.values(def.dataType).map((p) => createCommandParameterType(p, def)))
-		:	factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
-		undefined
-	);
-}
+	createParameterSignature(def: ParameterDefinition) {
+		return factory.createParameterDeclaration(
+			undefined,
+			undefined,
+			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)))
+			:	factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
+			undefined
+		);
+	}
 
-function createParameterSignature(def: ParameterDefinition) {
-	return factory.createParameterDeclaration(
-		undefined,
-		undefined,
-		factory.createIdentifier(def.id ?? 'value'),
-		def.optional ? factory.createToken(ts.SyntaxKind.QuestionToken) : undefined,
-		def.dataType ?
-			NodeClassFactory.instance.createUnionTypeNode(...Object.values(def.dataType).map((p) => createCommandParameterType(p, def)))
-		:	factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
-		undefined
-	);
-}
+	createTypeNodeForUOM(uom: number): ts.TypeNode {
+		return NodeClassFactory.instance.createTypeReferenceNode(UnitOfMeasure[uom] ?? 'Unknown', 'UnitOfMeasure');
+	}
 
-function createTypeNodeForUOM(uom: number): ts.TypeNode {
-	return NodeClassFactory.instance.createTypeReferenceNode(UnitOfMeasure[uom] ?? 'Unknown', 'UnitOfMeasure');
+	// #endregion Public Static Methods (4)
 }
 
+// #endregion Classes (1)
 // #endregion Functions (12)