isy-nodejs 1.0.8-alpha.0 → 1.3.24

package/src/CodeGeneration/NodeClassFactory.ts

@@ -1,15 +1,32 @@
-import { createWrappedNode, IndentationText, Project, QuoteKind, ScriptTarget, SourceFile, type Node } from 'ts-morph';
-import { factory, Statement, type Declaration } from 'typescript';
-import ts from 'typescript';
+import {
+	type Node,
+	createWrappedNode,
+	IndentationText,
+	Project,
+	QuoteKind,
+	ScriptTarget,
+	SourceFile,
+	TextChange,
+} from 'ts-morph';
+import ts, { type Declaration, factory, idText, Statement } from 'typescript';
 
 import type { Driver } from '../Definitions/Global/Drivers.js';
 import { UnitOfMeasure } from '../Definitions/Global/UOM.js';
 
+import { types } from 'util';
 import { Family } from '../Definitions/index.js';
-import { CommandDefinition, DataTypeDefinition, DriverDefinition, NodeClassDefinition, ParameterDefinition } from '../Model/ClassDefinition.js';
+import {
+	CommandDefinition,
+	DataTypeDefinition,
+	DriverDefinition,
+	NodeClassDefinition,
+	ParameterDefinition,
+} from '../Model/ClassDefinition.js';
 import { EnumDefinitionMap } from '../Model/EnumDefinition.js';
 import { CodeFactory } from './CodeFactory.js';
 
+import { createMemberName } from './EnumFactory.js';
+
 // #region Type aliases (1)
 
 type GeneratedNodeClass<T extends Family> = {
@@ -30,7 +47,8 @@ export class NodeClassFactory extends CodeFactory {
 
 	public static _basePath: string;
 	public static project = new Project({
-		compilerOptions: { target: ScriptTarget.ESNext, module: ts.ModuleKind.ESNext },
+		//@ts-ignore
+		compilerOptions: { target: ScriptTarget.ESNext, module: ts.ModuleKind.Node18 },
 		manipulationSettings: {
 			usePrefixAndSuffixTextForRename: true,
 			quoteKind: QuoteKind.Single,
@@ -38,8 +56,7 @@ export class NodeClassFactory extends CodeFactory {
 			indentationText: IndentationText.Tab,
 			newLineKind: ts.NewLineKind.CarriageReturnLineFeed,
 			insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: true,
-
-		}
+		},
 	});
 
 	static instance: NodeClassFactory = new NodeClassFactory(ts.factory);
@@ -60,10 +77,12 @@ export class NodeClassFactory extends CodeFactory {
 
 	// #region Public Static Methods (4)
 
-	public static buildNodeClasses<T extends Family>(map: { [x: string]: NodeClassDefinition<T> }): GeneratedNodeClass<T>[] {
+	public static buildNodeClasses<T extends Family>(map: {
+		[x: string]: NodeClassDefinition<T>;
+	}): GeneratedNodeClass<T>[] {
 		return Object.values(map)
-			.filter((p) => !p.equivalentTo)
-			.map((p) => {
+			.filter(p => !p.equivalentTo)
+			.map(p => {
 				try {
 					return NodeClassFactory.instance.createNodeClass(p);
 				} catch (e) {
@@ -72,79 +91,45 @@ 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.ES2024, true, ts.ScriptKind.TS);
 		//@ts-expect-error
 
 		sf.statements = [
+			this.createImportDeclaration('../../../Definitions/Global/index.js', ['Family', ' UnitOfMeasure']),
+			this.createImportDeclaration('../../../Model/NodeInfo.js', ['NodeInfo'], true),
+			this.createImportDeclaration('../../../ISY.js', ['ISY']),
+			this.createImportDeclaration('../../../ISYNode.js', ['ISYNode']),
+			this.createImportDeclaration('../../ISYDeviceNode.js', ['ISYDeviceNode']),
+			this.createImportDeclaration('../index.js', ['Base']),
+			this.createImportDeclaration('../../../Definitions/Global/Drivers.js', ['Driver']),
+			this.createImportDeclaration('type-fest', ['IntRange'], true),
+			this.createImportDeclaration('../../../Model/DriverState,js', ['DriverState'], true),
 			factory.createImportDeclaration(
 				undefined,
-				factory.createImportClause(false, undefined, factory.createNamedImports([factory.createImportSpecifier(false, undefined, factory.createIdentifier('UnitOfMeasure'))])),
-				factory.createStringLiteral('../../../Definitions/Global/UOM.js'),
-				undefined
-			),
-			factory.createImportDeclaration(
-				undefined,
-				factory.createImportClause(false, undefined, factory.createNamedImports([factory.createImportSpecifier(false, undefined, factory.createIdentifier('Family'))])),
-				factory.createStringLiteral('../../../Definitions/Global/Families.js'),
-				undefined
-			),
-			factory.createImportDeclaration(
-				undefined,
-				factory.createImportClause(true, undefined, factory.createNamedImports([factory.createImportSpecifier(false, undefined, factory.createIdentifier('NodeInfo'))])),
-				factory.createStringLiteral('../../../Model/NodeInfo.js'),
-				undefined
-			),
-			NodeClassFactory.instance.createImportDeclaration('../../../ISY.js', ['ISY']),
-			factory.createImportDeclaration(
-				undefined,
-				factory.createImportClause(true, undefined, factory.createNamedImports([factory.createImportSpecifier(false, undefined, factory.createIdentifier('ISYNode'))])),
-				factory.createStringLiteral('../../../ISYNode.js'),
-				undefined
-			),
-			factory.createImportDeclaration(
-				undefined,
-				factory.createImportClause(false, undefined, factory.createNamedImports([factory.createImportSpecifier(false, undefined, factory.createIdentifier('Base'))])),
-				factory.createStringLiteral('../index.js'),
-				undefined
-			),
-			factory.createImportDeclaration(
-				undefined,
-				factory.createImportClause(false, undefined, factory.createNamedImports([factory.createImportSpecifier(false, undefined, factory.createIdentifier('ISYDeviceNode'))])),
-				factory.createStringLiteral('../../ISYDeviceNode.js'),
-				undefined
-			),
-			factory.createImportDeclaration(
-				undefined,
-				factory.createImportClause(false, undefined, factory.createNamedImports([factory.createImportSpecifier(false, undefined, factory.createIdentifier('Driver'))])),
-				factory.createStringLiteral('../../../Definitions/Global/Drivers.js'),
-				undefined
-			),
-			factory.createImportDeclaration(
-				undefined,
-				factory.createImportClause(false, undefined, factory.createNamedImports([factory.createImportSpecifier(false, undefined, factory.createIdentifier(Family[nodeClassDef.family]))])),
+				factory.createImportClause(
+					false,
+					undefined,
+					factory.createNamedImports([
+						factory.createImportSpecifier(false, undefined, factory.createIdentifier(Family[nodeClassDef.family])),
+					])
+				),
 				factory.createStringLiteral('../../../Definitions/index.js'),
 				undefined
 			),
-			factory.createImportDeclaration(
-				undefined,
-				factory.createImportClause(true, undefined, factory.createNamedImports([factory.createImportSpecifier(false, undefined, factory.createIdentifier('DriverState'))])),
-				factory.createStringLiteral('../../../Model/DriverState.js'),
-				undefined
-			),
-			factory.createImportDeclaration(
-				undefined,
-				factory.createImportClause(false, undefined, factory.createNamedImports([factory.createImportSpecifier(false, undefined, factory.createIdentifier('NodeFactory'))])),
-				factory.createStringLiteral('../../NodeFactory.js'),
-				undefined
-			),
+			this.createImportDeclaration('../../NodeFactory.js', ['NodeFactory']),
 			factory.createVariableStatement(
 				undefined,
 				factory.createVariableDeclarationList(
-					[factory.createVariableDeclaration(factory.createIdentifier('nodeDefId'), undefined, undefined, factory.createStringLiteral(nodeClassDef.id))],
+					[
+						factory.createVariableDeclaration(
+							factory.createIdentifier('nodeDefId'),
+							undefined,
+							undefined,
+							factory.createStringLiteral(nodeClassDef.id)
+						),
+					],
 					ts.NodeFlags.Const
 				)
 			),
@@ -152,42 +137,55 @@ export class NodeClassFactory extends CodeFactory {
 				undefined,
 				factory.createIdentifier('Commands'),
 				undefined,
-				factory.createTypeReferenceNode(factory.createQualifiedName(factory.createIdentifier(nodeClassDef.name), factory.createIdentifier('Commands')), undefined)
+				factory.createTypeReferenceNode(this.createQualifiedName(nodeClassDef.name, 'Commands', 'Type'))
 			),
 
 			factory.createTypeAliasDeclaration(
 				undefined,
 				factory.createIdentifier('Drivers'),
 				undefined,
-				factory.createTypeReferenceNode(factory.createQualifiedName(factory.createIdentifier(nodeClassDef.name), factory.createIdentifier('Drivers')), undefined)
+				factory.createTypeReferenceNode(this.createQualifiedName(nodeClassDef.name, 'Drivers', 'Type'), undefined)
 			),
 
 			factory.createClassDeclaration(
-				[],
-				factory.createIdentifier(`${nodeClassDef.name}Node`),
+				[factory.createToken(ts.SyntaxKind.ExportKeyword)],
+				factory.createIdentifier(`${nodeClassDef.name}`),
 				undefined,
 				[
 					factory.createHeritageClause(ts.SyntaxKind.ExtendsKeyword, [
 						factory.createExpressionWithTypeArguments(factory.createIdentifier('Base'), [
 							factory.createTypeReferenceNode(factory.createIdentifier('Drivers'), undefined),
-							factory.createTypeReferenceNode(factory.createIdentifier('Commands'), undefined)
-						])
+							factory.createTypeReferenceNode(factory.createIdentifier('Commands'), undefined),
+						]),
 					]),
 					factory.createHeritageClause(ts.SyntaxKind.ImplementsKeyword, [
-						factory.createExpressionWithTypeArguments(factory.createPropertyAccessExpression(factory.createIdentifier(nodeClassDef.name), factory.createIdentifier('Interface')), undefined)
-					])
+						factory.createExpressionWithTypeArguments(
+							factory.createPropertyAccessExpression(
+								factory.createIdentifier(nodeClassDef.name),
+								factory.createIdentifier('Interface')
+							),
+							undefined
+						),
+					]),
 				],
 				[
 					factory.createPropertyDeclaration(
-						[factory.createToken(ts.SyntaxKind.PublicKeyword), factory.createToken(ts.SyntaxKind.OverrideKeyword), factory.createToken(ts.SyntaxKind.ReadonlyKeyword)],
+						[
+							factory.createToken(ts.SyntaxKind.PublicKeyword),
+							factory.createToken(ts.SyntaxKind.OverrideKeyword),
+							factory.createToken(ts.SyntaxKind.ReadonlyKeyword),
+						],
 						factory.createIdentifier('commands'),
 						undefined,
 						undefined,
 						factory.createObjectLiteralExpression(
 							[
-								...Object.values(nodeClassDef.commands).map((c) =>
-									factory.createPropertyAssignment(factory.createIdentifier(c.id), factory.createPropertyAccessExpression(factory.createThis(), factory.createIdentifier(c.name)))
-								)
+								...Object.values(nodeClassDef.commands).map(c =>
+									factory.createPropertyAssignment(
+										factory.createIdentifier(c.id),
+										factory.createPropertyAccessExpression(factory.createThis(), factory.createIdentifier(c.name))
+									)
+								),
 							],
 							true
 						)
@@ -209,11 +207,13 @@ export class NodeClassFactory extends CodeFactory {
 					NodeClassFactory.instance.createPropertyDeclaration(
 						'implements',
 						factory.createArrayLiteralExpression(
-							nodeClassDef.implementedBy ?
-								[NodeClassFactory.instance.createStringLiteral(nodeClassDef.id)].concat(
-									!nodeClassDef.implements || nodeClassDef.implements.length == 0 ? [] : nodeClassDef.implements?.map((p) => factory.createStringLiteral(p))
-								)
-							:	[NodeClassFactory.instance.createStringLiteral(nodeClassDef.id)]
+							nodeClassDef.implementedBy
+								? [NodeClassFactory.instance.createStringLiteral(nodeClassDef.id)].concat(
+										!nodeClassDef.implements || nodeClassDef.implements.length == 0
+											? []
+											: nodeClassDef.implements?.map(p => factory.createStringLiteral(p))
+									)
+								: [NodeClassFactory.instance.createStringLiteral(nodeClassDef.id)]
 						),
 						NodeClassFactory.instance.createModifiers(ts.ModifierFlags.Static | ts.ModifierFlags.Override)
 					),
@@ -221,13 +221,17 @@ export class NodeClassFactory extends CodeFactory {
 						[factory.createToken(ts.SyntaxKind.DeclareKeyword), factory.createToken(ts.SyntaxKind.ReadonlyKeyword)],
 						factory.createIdentifier('nodeDefId'),
 						undefined,
-						nodeClassDef.equivalents ?
-							NodeClassFactory.instance.createUnionTypeNode(
-								...[NodeClassFactory.instance.createLiteralTypeNode(nodeClassDef.id)].concat(
-									!nodeClassDef.equivalents || nodeClassDef.equivalents.length == 0 ? [] : nodeClassDef.equivalents?.map((p) => factory.createLiteralTypeNode(factory.createStringLiteral(p)))
+						nodeClassDef.equivalents
+							? NodeClassFactory.instance.createUnionTypeNode(
+									...[NodeClassFactory.instance.createLiteralTypeNode(nodeClassDef.id)].concat(
+										!nodeClassDef.equivalents || nodeClassDef.equivalents.length == 0
+											? []
+											: nodeClassDef.equivalents?.map(p =>
+													factory.createLiteralTypeNode(factory.createStringLiteral(p))
+												)
+									)
 								)
-							)
-						:	NodeClassFactory.instance.createLiteralTypeNode(nodeClassDef.id),
+							: NodeClassFactory.instance.createLiteralTypeNode(nodeClassDef.id),
 						undefined
 					),
 					factory.createConstructorDeclaration(
@@ -246,38 +250,56 @@ export class NodeClassFactory extends CodeFactory {
 								undefined,
 								factory.createIdentifier('nodeInfo'),
 								undefined,
-								factory.createTypeReferenceNode(factory.createIdentifier('NodeInfo'), undefined),
+								factory.createTypeReferenceNode(factory.createIdentifier('NodeInfo'), [
+									this.createTypeReferenceNode(Family[nodeClassDef.family], 'Family'),
+								]),
 								undefined
-							)
+							),
 						],
 						factory.createBlock(
 							[
-								factory.createExpressionStatement(factory.createCallExpression(factory.createSuper(), undefined, [factory.createIdentifier('isy'), factory.createIdentifier('nodeInfo')])),
-								...Object.values(nodeClassDef.drivers).map(p => NodeClassFactory.instance.createDriverInitializationStatement(p))
+								factory.createExpressionStatement(
+									factory.createCallExpression(factory.createSuper(), undefined, [
+										factory.createIdentifier('isy'),
+										factory.createIdentifier('nodeInfo'),
+									])
+								),
+								...Object.values(nodeClassDef.drivers).map(p =>
+									NodeClassFactory.instance.createDriverInitializationStatement(p)
+								),
 							],
 							true
 						)
 					),
 					...Object.values(nodeClassDef.commands).map(p => NodeClassFactory.instance.createCommandMethodDeclaration(p)),
-					...Object.values(nodeClassDef.drivers).map(p => NodeClassFactory.instance.createDriverGetDeclaration(p))
+					...Object.values(nodeClassDef.drivers).map(p => NodeClassFactory.instance.createDriverGetDeclaration(p)),
 				]
 			),
 			factory.createExpressionStatement(
-				factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier('NodeFactory'), factory.createIdentifier('register')), undefined, [
-					factory.createIdentifier(`${nodeClassDef.name}Node`)
-				])
+				factory.createCallExpression(
+					factory.createPropertyAccessExpression(
+						factory.createIdentifier('NodeFactory'),
+						factory.createIdentifier('register')
+					),
+					undefined,
+					[factory.createIdentifier(`${nodeClassDef.name}`)]
+				)
 			),
 
-			...(nodeClassDef.equivalents ?
-				nodeClassDef.equivalents?.map((p) =>
-					factory.createExpressionStatement(
-						factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier('NodeFactory'), factory.createIdentifier('register')), undefined, [
-							factory.createIdentifier(`${nodeClassDef.name}Node`),
-							factory.createStringLiteral(p)
-						])
+			...(nodeClassDef.equivalents
+				? nodeClassDef.equivalents?.map(p =>
+						factory.createExpressionStatement(
+							factory.createCallExpression(
+								factory.createPropertyAccessExpression(
+									factory.createIdentifier('NodeFactory'),
+									factory.createIdentifier('register')
+								),
+								undefined,
+								[factory.createIdentifier(`${nodeClassDef.name}`), factory.createStringLiteral(p)]
+							)
+						)
 					)
-				)
-			:	[]),
+				: []),
 			factory.createModuleDeclaration(
 				[factory.createToken(ts.SyntaxKind.ExportKeyword)],
 				factory.createIdentifier(nodeClassDef.name),
@@ -289,18 +311,23 @@ export class NodeClassFactory extends CodeFactory {
 						[
 							factory.createHeritageClause(ts.SyntaxKind.ExtendsKeyword, [
 								factory.createExpressionWithTypeArguments(factory.createIdentifier('Omit'), [
-									NodeClassFactory.instance.createTypeReferenceNode('InstanceType', NodeClassFactory.instance.factory.createTypeQueryNode(factory.createIdentifier(`${nodeClassDef.name}Node`))),
+									NodeClassFactory.instance.createTypeReferenceNode(
+										'InstanceType',
+										NodeClassFactory.instance.factory.createTypeQueryNode(
+											factory.createIdentifier(`${nodeClassDef.name}`)
+										)
+									),
 									factory.createTypeOperatorNode(
 										ts.SyntaxKind.KeyOfKeyword,
 										factory.createTypeReferenceNode(factory.createIdentifier('ISYDeviceNode'), [
 											factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
 											factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
 											factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
-											factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
+											factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
 										])
-									)
-								])
-							])
+									),
+								]),
+							]),
 						],
 						[
 							/*factory.createPropertySignature(
@@ -333,27 +360,39 @@ export class NodeClassFactory extends CodeFactory {
 									factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
 									factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
 									factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
-									factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
+									factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
 								]),
 								undefined
-							)
+							),
 						],
-						factory.createTypePredicateNode(undefined, factory.createIdentifier('node'), factory.createTypeReferenceNode(factory.createIdentifier(`${nodeClassDef.name}Node`), undefined)),
-						NodeClassFactory.instance.createBlock(true,
+						factory.createTypePredicateNode(
+							undefined,
+							factory.createIdentifier('node'),
+							factory.createTypeReferenceNode(factory.createIdentifier(`${nodeClassDef.name}`), undefined)
+						),
+						NodeClassFactory.instance.createBlock(
+							true,
 							NodeClassFactory.instance.createReturnStatement(
 								factory.createCallExpression(
 									factory.createPropertyAccessExpression(
 										factory.createArrayLiteralExpression(
-											nodeClassDef.equivalents ?
-												[NodeClassFactory.instance.createStringLiteral(nodeClassDef.id)].concat(
-													!nodeClassDef.equivalents || nodeClassDef.equivalents.length == 0 ? [] : nodeClassDef.equivalents?.map((p) => factory.createStringLiteral(p))
-												)
-											:	[NodeClassFactory.instance.createStringLiteral(nodeClassDef.id)]
+											nodeClassDef.equivalents
+												? [NodeClassFactory.instance.createStringLiteral(nodeClassDef.id)].concat(
+														!nodeClassDef.equivalents || nodeClassDef.equivalents.length == 0
+															? []
+															: nodeClassDef.equivalents?.map(p => factory.createStringLiteral(p))
+													)
+												: [NodeClassFactory.instance.createStringLiteral(nodeClassDef.id)]
 										),
 										'includes'
 									),
 									undefined,
-									[factory.createPropertyAccessExpression(factory.createIdentifier('node'), factory.createIdentifier('nodeDefId'))]
+									[
+										factory.createPropertyAccessExpression(
+											factory.createIdentifier('node'),
+											factory.createIdentifier('nodeDefId')
+										),
+									]
 								)
 							)
 						)
@@ -377,9 +416,13 @@ export class NodeClassFactory extends CodeFactory {
 									NodeClassFactory.instance.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
 								),
 								undefined
-							)
+							),
 						],
-						factory.createTypePredicateNode(undefined, factory.createIdentifier('node'), factory.createTypeReferenceNode(factory.createIdentifier(`${nodeClassDef.name}Node`), undefined)),
+						factory.createTypePredicateNode(
+							undefined,
+							factory.createIdentifier('node'),
+							factory.createTypeReferenceNode(factory.createIdentifier(`${nodeClassDef.name}`), undefined)
+						),
 						NodeClassFactory.instance.createBlock(
 							true,
 
@@ -387,16 +430,23 @@ export class NodeClassFactory extends CodeFactory {
 								factory.createCallExpression(
 									factory.createPropertyAccessExpression(
 										factory.createArrayLiteralExpression(
-											nodeClassDef.implementedBy ?
-												[NodeClassFactory.instance.createStringLiteral(nodeClassDef.id)].concat(
-													!nodeClassDef.implementedBy || nodeClassDef.implementedBy.length == 0 ? [] : nodeClassDef.implementedBy?.map((p) => factory.createStringLiteral(p))
-												)
-											:	[NodeClassFactory.instance.createStringLiteral(nodeClassDef.id)]
+											nodeClassDef.implementedBy
+												? [NodeClassFactory.instance.createStringLiteral(nodeClassDef.id)].concat(
+														!nodeClassDef.implementedBy || nodeClassDef.implementedBy.length == 0
+															? []
+															: nodeClassDef.implementedBy?.map(p => factory.createStringLiteral(p))
+													)
+												: [NodeClassFactory.instance.createStringLiteral(nodeClassDef.id)]
 										),
 										'includes'
 									),
 									undefined,
-									[factory.createPropertyAccessExpression(factory.createIdentifier('node'), factory.createIdentifier('nodeDefId'))]
+									[
+										factory.createPropertyAccessExpression(
+											factory.createIdentifier('node'),
+											factory.createIdentifier('nodeDefId')
+										),
+									]
 								)
 							)
 						)
@@ -420,16 +470,21 @@ export class NodeClassFactory extends CodeFactory {
 								undefined,
 								factory.createIdentifier('nodeInfo'),
 								undefined,
-								factory.createTypeReferenceNode(factory.createIdentifier('NodeInfo'), undefined),
+								factory.createTypeReferenceNode(factory.createIdentifier('NodeInfo'), [
+									this.createTypeReferenceNode(Family[nodeClassDef.family], 'Family'),
+								]),
 								undefined
-							)
+							),
 						],
 						undefined,
 						factory.createBlock(
 							[
 								factory.createReturnStatement(
-									factory.createNewExpression(factory.createIdentifier(`${nodeClassDef.name}Node`), undefined, [factory.createIdentifier('isy'), factory.createIdentifier('nodeInfo')])
-								)
+									factory.createNewExpression(factory.createIdentifier(`${nodeClassDef.name}`), undefined, [
+										factory.createIdentifier('isy'),
+										factory.createIdentifier('nodeInfo'),
+									])
+								),
 							],
 							true
 						)
@@ -437,25 +492,73 @@ export class NodeClassFactory extends CodeFactory {
 					factory.createVariableStatement(
 						[factory.createToken(ts.SyntaxKind.ExportKeyword)],
 						factory.createVariableDeclarationList(
-							[factory.createVariableDeclaration(factory.createIdentifier('Node'), undefined, undefined, factory.createIdentifier(`${nodeClassDef.name}Node`))],
+							[
+								factory.createVariableDeclaration(
+									factory.createIdentifier('Node'),
+									undefined,
+									undefined,
+									factory.createIdentifier(`${nodeClassDef.name}`)
+								),
+							],
 							ts.NodeFlags.Const
 						)
 					),
-					factory.createTypeAliasDeclaration(
+					this.createVariableStatement(
+						'Class',
+
+						factory.createIdentifier(`${nodeClassDef.name}`),
+						true
+					),
+
+					this.createModuleDeclaration(
+						'Commands',
+						this.createModuleBlock(
+							factory.createTypeAliasDeclaration(
+								[factory.createToken(ts.SyntaxKind.ExportKeyword)],
+								factory.createIdentifier('Type'),
+								undefined,
+								factory.createTypeLiteralNode([
+									...Object.values(nodeClassDef.commands).map(NodeClassFactory.instance.createCommandSignature),
+								])
+							)
+						),
+						ts.ModifierFlags.Export
+					),
+					this.factory.createEnumDeclaration(
 						[factory.createToken(ts.SyntaxKind.ExportKeyword)],
 						factory.createIdentifier('Commands'),
-						undefined,
-						factory.createTypeLiteralNode([...Object.values(nodeClassDef.commands).map(NodeClassFactory.instance.createCommandSignature)])
+						[
+							...Object.values(nodeClassDef.commands).map(p =>
+								factory.createEnumMember(p.name, this.createLiteral(p.id))
+							),
+						]
+					),
+					this.createModuleDeclaration(
+						'Drivers',
+						this.createModuleBlock(
+							factory.createTypeAliasDeclaration(
+								[factory.createToken(ts.SyntaxKind.ExportKeyword)],
+								factory.createIdentifier('Type'),
+								undefined,
+								factory.createTypeLiteralNode([
+									...Object.values(nodeClassDef.drivers).map(NodeClassFactory.instance.createDriverSignature),
+								])
+							)
+						),
+						ts.ModifierFlags.Export
 					),
-					factory.createTypeAliasDeclaration(
+					this.factory.createEnumDeclaration(
 						[factory.createToken(ts.SyntaxKind.ExportKeyword)],
 						factory.createIdentifier('Drivers'),
-						undefined,
-						factory.createTypeLiteralNode([...Object.values(nodeClassDef.drivers).map(NodeClassFactory.instance.createDriverSignature)])
-					)
+						[
+							...Object.values(nodeClassDef.drivers).map(p =>
+								factory.createEnumMember(p.name, this.createLiteral(p.id))
+							),
+						]
+					),
 				]),
 				ts.NodeFlags.Namespace
-			)
+			),
 		];
 		//let f = createWrappedNode(sf);
 		let p = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
@@ -473,11 +576,11 @@ export class NodeClassFactory extends CodeFactory {
 			trimTrailingWhitespace: true,
 			ensureNewLineAtEndOfFile: true,
 			indentStyle: ts.IndentStyle.Smart,
-
 		});
+		f.fixUnusedIdentifiers();
+
 		let currentKind = ts.SyntaxKind.Unknown;
 		for (const s of f.getStatements()) {
-
 			if (currentKind.valueOf() != s.getKind().valueOf()) {
 				if (currentKind != ts.SyntaxKind.Unknown) {
 					s.prependWhitespace('\n');
@@ -492,7 +595,7 @@ export class NodeClassFactory extends CodeFactory {
 			id: nodeClassDef.id,
 			path,
 			statements: sf.statements,
-			sourceFile: f
+			sourceFile: f,
 		};
 	}
 
@@ -506,7 +609,9 @@ export class NodeClassFactory extends CodeFactory {
 	}
 
 	public static generateClassesForFamily<T extends Family>(family: T): GeneratedNodeClass<T>[] {
-		return NodeClassFactory.buildNodeClasses<T>(NodeClassDefinition.Map.get(family) as { [x: string]: NodeClassDefinition<T> });
+		return NodeClassFactory.buildNodeClasses<T>(
+			NodeClassDefinition.Map.get(family) as { [x: string]: NodeClassDefinition<T> }
+		);
 	}
 
 	// #region Functions (12)
@@ -515,43 +620,100 @@ export class NodeClassFactory extends CodeFactory {
 		return {
 			family,
 			path: `/${Family[family]}/Generated/index.ts`,
-			statements: [...classes.map((p) => factory.createExportDeclaration(undefined, false, undefined, factory.createStringLiteral(`./${p.name}.js`), undefined))]
+			statements: [
+				...classes.map(p =>
+					factory.createExportDeclaration(
+						undefined,
+						false,
+						undefined,
+						factory.createStringLiteral(`./${p.name}.js`),
+						undefined
+					)
+				),
+			],
 		};
 	}
 
-	createCommandArguments(def: CommandDefinition)
-	{
-		 let c = [
-				factory.createStringLiteral(def.id)];
+	createCommandArguments(def: CommandDefinition) {
+		let c = [factory.createStringLiteral(def.id)];
 		let n = [];
-		let r = [];
+		let r: ParameterDefinition[] = [];
 
-		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
-				{
+		if (def.parameters) {
+			for (let p of def.parameters) {
+				let p2 = p;
+				if (!p2?.id || p2.id == 'value') {
+					n.push(this.createUOMParameterArgument(p2));
+					//.push(factory.createIdentifier(p2.name ?? 'value'));
+				} else {
 					r.push(p2);
 				}
 			}
 		}
-		let fnl = [...c,...n,
-
+		let fnl = [
+			...c,
+			...n,
 
-						...(r.length > 0 ? [factory.createObjectLiteralExpression(
-							r.map((q) => factory.createPropertyAssignment(factory.createIdentifier(q.id ?? 'value'), factory.createIdentifier(q.name ?? 'value'))),
+			...(r.length > 0
+				? [
+						factory.createObjectLiteralExpression(
+							r.map(q =>
+								factory.createPropertyAssignment(
+									factory.createIdentifier(q.id ?? 'value'),
+									this.createUOMParameterArgument(q)
+								)
+							),
 							false
-						)] : [])
+						),
+					]
+				: []),
+		];
+		return fnl.length > 0 ? fnl : undefined;
+	}
 
+	createUOMParameterArgument(parent: ParameterDefinition) {
+		if (parent.dataType.length == 1) {
+			let dt = parent.dataType[0];
+			return factory.createArrayLiteralExpression([
+				factory.createIdentifier(parent.name),
+				factory.createPropertyAccessChain(
+					factory.createIdentifier('UnitOfMeasure'),
+					undefined,
+					factory.createIdentifier(UnitOfMeasure[dt.uom] ?? 'Unknown')
+				),
+			]);
+		}
+		return factory.createIdentifier(parent.name ?? 'value');
+	}
 
-			];
-		return fnl.length > 0 ? fnl : undefined;
+	createCommandMethodArguments(def: CommandDefinition): ts.ParameterDeclaration[] {
+		let p1: ts.ParameterDeclaration[] = [];
+		let p2: ts.ParameterDeclaration[] = [];
+
+		for (let p of def.parameters) {
+			if (p.optional) {
+				p2.push(this.createParameterDeclarationSignature(p));
+			} else {
+				p1.push(this.createParameterDeclarationSignature(p));
+			}
+		}
+
+		return [...p1, ...p2];
+	}
+
+	createCommandSignatureArguments(def: CommandDefinition): ts.ParameterDeclaration[] {
+		let p1: ts.ParameterDeclaration[] = [];
+		let p2: ts.ParameterDeclaration[] = [];
+
+		for (let p of def.parameters) {
+			if (p.optional) {
+				p2.push(this.createParameterSignature(p));
+			} else {
+				p1.push(this.createParameterSignature(p));
+			}
+		}
+
+		return [...p1, ...p2];
 	}
 
 	createCommandMethodDeclaration(def: CommandDefinition) {
@@ -561,17 +723,37 @@ export class NodeClassFactory extends CodeFactory {
 			factory.createIdentifier(def.name),
 			undefined,
 			undefined,
-
-			def.parameters ? Object.values(def.parameters).map(NodeClassFactory.instance.createParameterDeclarationSignature.bind(this)) : undefined,
+			def.parameters ? this.createCommandMethodArguments(def) : [],
 			undefined,
-			factory.createBlock(
-				[factory.createReturnStatement(
-					factory.createCallExpression(factory.createPropertyAccessExpression(factory.createThis(), factory.createIdentifier('sendCommand')), undefined,NodeClassFactory.instance.createCommandArguments(def))
-				)]
-			)
+			factory.createBlock([
+				factory.createReturnStatement(
+					factory.createCallExpression(
+						factory.createPropertyAccessExpression(factory.createThis(), factory.createIdentifier('sendCommand')),
+						undefined,
+						NodeClassFactory.instance.createCommandArguments(def)
+					)
+				),
+			])
 		);
 	}
 
+	addUOMType(def: DataTypeDefinition, typeNode: ts.TypeNode) {
+		return factory.createTupleTypeNode([
+			typeNode,
+			factory.createTypeReferenceNode(
+				factory.createQualifiedName(
+					factory.createIdentifier('UnitOfMeasure'),
+					factory.createIdentifier(UnitOfMeasure[def.uom])
+				),
+				undefined
+			),
+		]);
+	}
+
+	/*addMaybeUOMType(def: DataTypeDefinition, typeNode: ts.TypeNode) {
+		return factory.createTypeParameterDeclaration(typeNode, factory.createTypeReferenceNode(factory.createQualifiedName(factory.createIdentifier('UnitOfMeasure'), factory.createIdentifier(UnitOfMeasure[def.uom])), undefined));
+	}*/
+
 	createCommandParameterType(def: DataTypeDefinition, parent: ParameterDefinition): ts.TypeNode {
 		if (def.enum) {
 			{
@@ -580,12 +762,20 @@ export class NodeClassFactory extends CodeFactory {
 
 					// ?? EnumDefinitionMap[Family.Global]?[def.indexId]
 					if (enumDef) {
-						return factory.createTypeReferenceNode(factory.createQualifiedName(factory.createIdentifier(Family[parent.classDef.family]), factory.createIdentifier(enumDef.name)), undefined);
+						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.keys(def.values).map(p => factory.createLiteralTypeNode(factory.createNumericLiteral(p)))
+					);
 				}
 
 				//   return NodeClassFactory.instance.createUnionTypeNode(...
@@ -611,15 +801,27 @@ export class NodeClassFactory extends CodeFactory {
 				factory.createParenthesizedType(
 					factory.createFunctionTypeNode(
 						undefined,
-						def.parameters ? Object.values(def.parameters).map(p => NodeClassFactory.instance.createParameterSignature(p)) : [],
+						def.parameters ? NodeClassFactory.instance.createCommandSignatureArguments(def) : [],
 
-						factory.createTypeReferenceNode(factory.createIdentifier('Promise'), [factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword)])
+						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.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))
+					),
+				]),
 			])
 		);
 	}
@@ -629,16 +831,21 @@ export class NodeClassFactory extends CodeFactory {
 			[factory.createToken(ts.SyntaxKind.PublicKeyword)],
 			factory.createIdentifier(def.name),
 			[],
-			NodeClassFactory.instance.createUnionTypeNode(...def.dataType?.map((p) => NodeClassFactory.instance.createDriverPropertyReturnType(p, def))),
+			NodeClassFactory.instance.createUnionTypeNode(
+				...def.dataType?.map(p => NodeClassFactory.instance.createDriverReturnType(p, def))
+			),
 			factory.createBlock(
 				[
 					factory.createReturnStatement(
 						factory.createPropertyAccessChain(
-							factory.createPropertyAccessExpression(factory.createPropertyAccessExpression(factory.createThis(), factory.createIdentifier('drivers')), factory.createIdentifier(def.id)),
+							factory.createPropertyAccessExpression(
+								factory.createPropertyAccessExpression(factory.createThis(), factory.createIdentifier('drivers')),
+								factory.createIdentifier(def.id)
+							),
 							factory.createToken(ts.SyntaxKind.QuestionDotToken),
 							factory.createIdentifier('value')
 						)
-					)
+					),
 				],
 				true
 			)
@@ -648,24 +855,49 @@ export class NodeClassFactory extends CodeFactory {
 	createDriverInitializationStatement(def: DriverDefinition): ts.Statement {
 		return factory.createExpressionStatement(
 			factory.createBinaryExpression(
-				factory.createPropertyAccessExpression(factory.createPropertyAccessExpression(factory.createThis(), factory.createIdentifier('drivers')), factory.createIdentifier(def.id)),
+				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.createElementAccessExpression(factory.createPropertyAccessExpression(factory.createIdentifier('nodeInfo'), factory.createIdentifier('state')), this.createStringLiteral(def.id)),
-					factory.createObjectLiteralExpression(
-						[
-							factory.createPropertyAssignment(
-								factory.createIdentifier('uom'),
-								factory.createPropertyAccessExpression(factory.createIdentifier('UnitOfMeasure'), factory.createIdentifier(UnitOfMeasure[def.dataType[0]?.uom] ?? 'Unknown'))
+				factory.createCallExpression(
+					factory.createPropertyAccessExpression(
+						factory.createIdentifier('Driver'),
+						factory.createIdentifier('create')
+					),
+					undefined,
+					[
+						factory.createStringLiteral(def.id),
+						factory.createThis(),
+						factory.createElementAccessExpression(
+							factory.createPropertyAccessExpression(
+								factory.createIdentifier('nodeInfo'),
+								factory.createIdentifier('state')
 							),
-							factory.createPropertyAssignment(factory.createIdentifier('label'), factory.createStringLiteral(def.label)),
-							factory.createPropertyAssignment(factory.createIdentifier('name'), factory.createStringLiteral(def.name))
-						],
-						false
-					)
-				])
+							this.createStringLiteral(def.id)
+						),
+						factory.createObjectLiteralExpression(
+							[
+								factory.createPropertyAssignment(
+									factory.createIdentifier('uom'),
+									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)
+								),
+							],
+							false
+						),
+					]
+				)
 			)
 		);
 	}
@@ -678,11 +910,19 @@ export class NodeClassFactory extends CodeFactory {
 
 					// ?? EnumDefinitionMap[Family.Global]?[def.indexId]
 					if (enumDef) {
-						return factory.createTypeReferenceNode(factory.createQualifiedName(factory.createIdentifier(Family[parent.classDef.family]), factory.createIdentifier(enumDef.name)), undefined);
+						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.keys(def.values).map(p => factory.createLiteralTypeNode(factory.createNumericLiteral(p)))
+					);
 				}
 
 				//   return NodeClassFactory.instance.createUnionTypeNode(...
@@ -695,6 +935,19 @@ export class NodeClassFactory extends CodeFactory {
 				// )))
 			}
 		}
+		if (
+			'min' in def &&
+			'max' in def &&
+			def.max < 1000 &&
+			def.min >= 0 &&
+			Number.isInteger(def.min) &&
+			Number.isInteger(def.max)
+		) {
+			return factory.createTypeReferenceNode(factory.createIdentifier('IntRange'), [
+				factory.createLiteralTypeNode(this.createLiteral(def.min)),
+				factory.createLiteralTypeNode(this.createLiteral(def.max)),
+			]);
+		}
 		return factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
 	}
 
@@ -708,38 +961,77 @@ export class NodeClassFactory extends CodeFactory {
 					undefined,
 					factory.createIdentifier('uom'),
 					undefined,
-					def.dataType ?
-						NodeClassFactory.instance.createUnionTypeNode(...def.dataType?.map((p) => NodeClassFactory.instance.createTypeNodeForUOM(p.uom)))
-					:	factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)
+					def.dataType
+						? NodeClassFactory.instance.createUnionTypeNode(
+								...def.dataType?.map(p => NodeClassFactory.instance.createTypeNodeForUOM(p.uom))
+							)
+						: factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)
 				),
 				factory.createPropertySignature(
 					undefined,
 					factory.createIdentifier('value'),
 					undefined,
-					def.dataType ?
-						NodeClassFactory.instance.createUnionTypeNode(...def.dataType.map((p) => NodeClassFactory.instance.createDriverSignatureReturnType(p, def)))
-					:	factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)
+					def.dataType
+						? NodeClassFactory.instance.createUnionTypeNode(
+								...def.dataType.map(p => NodeClassFactory.instance.createDriverReturnType(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))
 				),
-				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)))
 			])
 		);
 	}
 
-	createDriverSignatureReturnType(def: DataTypeDefinition, parent: DriverDefinition): ts.TypeNode {
+	createDriverReturnType(def: DataTypeDefinition, parent: DriverDefinition): ts.TypeNode {
 		if (def.enum) {
-			if (EnumDefinitionMap.has(parent.classDef.family)) {
-				var enumDef = EnumDefinitionMap.get(parent.classDef.family)[def.indexId];
+			{
+				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);
+					// ?? 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
+				// )))
 			}
 		}
+		if ('min' in def && 'max' in def && def.max < 1000 && def.min >= 0) {
+			return factory.createTypeReferenceNode(factory.createIdentifier('IntRange'), [
+				factory.createLiteralTypeNode(this.createLiteral(def.min)),
+				factory.createLiteralTypeNode(this.createLiteral(def.max)),
+			]);
+		}
 		return factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
 	}
 
@@ -749,9 +1041,11 @@ export class NodeClassFactory extends CodeFactory {
 			undefined,
 			factory.createIdentifier(def.name ?? 'value'),
 			def.optional ? factory.createToken(ts.SyntaxKind.QuestionToken) : undefined,
-			def.dataType ?
-				NodeClassFactory.instance.createUnionTypeNode(...def.dataType?.map((p) => NodeClassFactory.instance.createCommandParameterType(p, def)))
-			:	factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
+			def.dataType
+				? NodeClassFactory.instance.createUnionTypeNode(
+						...def.dataType?.map(p => NodeClassFactory.instance.createCommandParameterType(p, def))
+					)
+				: factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
 			undefined
 		);
 	}
@@ -762,9 +1056,11 @@ export class NodeClassFactory extends CodeFactory {
 			undefined,
 			factory.createIdentifier(def.id ?? 'value'),
 			def.optional ? factory.createToken(ts.SyntaxKind.QuestionToken) : undefined,
-			def.dataType ?
-				NodeClassFactory.instance.createUnionTypeNode(...def.dataType?.map((p) => NodeClassFactory.instance.createCommandParameterType(p, def)))
-			:	factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
+			def.dataType
+				? NodeClassFactory.instance.createUnionTypeNode(
+						...def.dataType?.map(p => NodeClassFactory.instance.createCommandParameterType(p, def))
+					)
+				: factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
 			undefined
 		);
 	}