isy-nodejs 1.0.8-alpha.0 → 1.3.24

package/package.cjs.json

@@ -1 +1 @@
-{ "type": "commonjs" }
+{ "type": "commonjs" }

package/package.json

@@ -1,78 +1,82 @@
 {
-    "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.8-alpha.0",
-    "author": {
-        "name": "Pradeep Mouli"
-    },
-    "scripts": {
-        "test": "mocha",
-        "prepublishOnly": "npm run build",
-        "linter": "eslint --ignore-path .gitignore .",
-        "clean": "rimraf ./dist/*",
-        "build:esm": "tsc -p ./tsconfig.esm.json",
-        "build:cjs": "tsc -p ./tsconfig.cjs.json && cp ./package.cjs.json ./dist/cjs/package.json",
-        "build": "npm run build:esm",
-        "build:esm:watch": "tsc -p ./tsconfig.esm.json --watch"
-    },
-    "keywords": [
-        "isy",
-        "universal devices",
-        "insteon",
-        "elk",
-        "ZWave"
-    ],
-    "directories": {
-        "test": "test",
-        "lib": "dist"
-    },
-    "exports": {
-        "./*": {
-            "require": {
-                "types": "./dist/cjs/types/*.d.ts",
-                "default": "./dist/cjs/*.js"
-            },
-            "import": {
-                "types": "./dist/esm/types/*.d.ts",
-                "default": "./dist/esm/*.js"
-            }
-        }
-    },
-    "main": "./dist/cjs/ISY.js",
-    "module": "./dist/esm/ISY.js",
-    "type": "module",
-    "devDependencies": {
-        "@types/node": "^22.7.5",
-        "@types/xml2js": "",
-        "@types/xmldoc": "",
-        "microdiff": "^1.4.0",
-        "mocha": "",
-        "rimraf": "^6.0.1"
-    },
-    "dependencies": {
-        "@log4js-node/log4js-api": "^1.0.2",
-        "@matter/general": "^0.11.6",
-        "@matter/main": "^0.11.6",
-        "@matter/types": "^0.11.4",
-        "@project-chip/matter-node.js": "^0.11.4",
-        "@project-chip/matter.js": "^0.11.6",
-        "@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",
-        "type-fest": "4.28.0",
-        "winston": "^3.17.0",
-        "ws": "^8.18.0",
-        "xml2js": "^0.6.2"
-    },
-    "bugs": {
-        "url": "https://github.com/pradeepmouli/udi-js/issues"
-    },
-    "publishConfig": {
-        "access": "public"
-    },
-    "gitHead": "4b88acc1e9ee5625c06cfa8cf7359aa0c3ff9faf"
+	"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.3.24",
+	"author": {
+		"name": "Pradeep Mouli"
+	},
+	"scripts": {
+		"test": "mocha",
+		"prepublishOnly": "npm run build",
+		"lint": "eslint --ignore-path .gitignore .",
+		"lint:fix": "eslint --ignore-path .gitignore . --fix",
+		"typecheck": "tsc --noEmit",
+		"clean": "rimraf ./dist/*",
+		"build:esm": "tsc -p ./tsconfig.json",
+		"build:cjs": "tsc -p ./tsconfig.cjs.json && cp ./package.cjs.json ./dist/cjs/package.json",
+		"build": "npm run build:esm",
+		"build:esm:watch": "tsc -p ./tsconfig.json --watch --noCheck"
+	},
+	"keywords": ["isy", "universal devices", "insteon", "elk", "ZWave"],
+	"directories": {
+		"test": "test",
+		"lib": "dist"
+	},
+	"exports": {
+		"./*": {
+			"require": {
+				"types": "./dist/cjs/types/*.d.ts",
+				"default": "./dist/cjs/*.js"
+			},
+			"import": {
+				"types": "./dist/esm/types/*.d.ts",
+				"default": "./dist/esm/*.js"
+			}
+		},
+		".": {
+			"require": {
+				"types": "./dist/cjs/types/ISY.d.ts",
+				"default": "./dist/cjs/ISY.js"
+			},
+			"import": {
+				"types": "./dist/esm/types/ISY.d.ts",
+				"default": "./dist/esm/ISY.js"
+			}
+		}
+	},
+	"main": "./dist/cjs/ISY.js",
+	"module": "./dist/esm/ISY.js",
+	"type": "module",
+
+	"devDependencies": {
+		"@log4js-node/log4js-api": "1.0.2",
+		"@types/ws": "^8.18.1",
+		"@types/xml2js": "^0.4.14",
+		"@types/xmldoc": "^2.0.0",
+		"microdiff": "^1.5.0"
+	},
+	"dependencies": {
+		"@matter/main": "^0.14.0",
+		"axios": "^1.10.0",
+		"camelcase": "^8.0.0",
+		"chalk": "^5.4.1",
+		"fast-xml-parser": "^5.2.5",
+		"import-meta-resolve": "^4.1.0",
+		"moderndash": "^4.0.0",
+		"p-mutex": "^0.1.0",
+		"winston": "^3.17.0",
+		"ws": "^8.18.2",
+		"xml2js": "^0.6.2"
+	},
+	"imports": {
+		"#Devices": "./src/Devices/*"
+	},
+	"bugs": {
+		"url": "https://github.com/pradeepmouli/udi-js/issues"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"gitHead": "f80638d852ef427b9beb52c814ec6ecf3f618ef1"
 }

package/src/CodeGeneration/CodeFactory.ts

@@ -22,7 +22,11 @@ export class CodeFactory {
 	}
 
 	createImportClause(isTypeOnly: boolean, name?: string, ...namedBindings: ts.NamedImportBindings[]): ts.ImportClause {
-		return ts.factory.createImportClause(isTypeOnly, this.createIdentifier(name), namedBindings.length ? namedBindings[0] : undefined);
+		return ts.factory.createImportClause(
+			isTypeOnly,
+			this.createIdentifier(name),
+			namedBindings.length ? namedBindings[0] : undefined
+		);
 	}
 
 	createAssertClause(elements: ts.NodeArray<ts.AssertEntry>, multiLine?: boolean): ts.AssertClause {
@@ -57,11 +61,25 @@ export class CodeFactory {
 		return ts.factory.createNamedImports(elements);
 	}
 
-	updateImportClause(node: ts.ImportClause, isTypeOnly: boolean, name?: string, ...namedBindings: ts.NamedImportBindings[]): ts.ImportClause {
-		return ts.factory.updateImportClause(node, isTypeOnly, this.createIdentifier(name), namedBindings.length ? namedBindings[0] : undefined);
+	updateImportClause(
+		node: ts.ImportClause,
+		isTypeOnly: boolean,
+		name?: string,
+		...namedBindings: ts.NamedImportBindings[]
+	): ts.ImportClause {
+		return ts.factory.updateImportClause(
+			node,
+			isTypeOnly,
+			this.createIdentifier(name),
+			namedBindings.length ? namedBindings[0] : undefined
+		);
 	}
 
-	updateAssertClause(node: ts.AssertClause, elements: ts.NodeArray<ts.AssertEntry>, multiLine?: boolean): ts.AssertClause {
+	updateAssertClause(
+		node: ts.AssertClause,
+		elements: ts.NodeArray<ts.AssertEntry>,
+		multiLine?: boolean
+	): ts.AssertClause {
 		return ts.factory.updateAssertClause(node, elements, multiLine);
 	}
 
@@ -69,11 +87,19 @@ export class CodeFactory {
 		return ts.factory.updateAssertEntry(node, this.createIdentifier(name)!, value);
 	}
 
-	updateImportTypeAssertionContainer(node: ts.ImportTypeAssertionContainer, clause: ts.AssertClause, multiLine?: boolean): ts.ImportTypeAssertionContainer {
+	updateImportTypeAssertionContainer(
+		node: ts.ImportTypeAssertionContainer,
+		clause: ts.AssertClause,
+		multiLine?: boolean
+	): ts.ImportTypeAssertionContainer {
 		return ts.factory.updateImportTypeAssertionContainer(node, clause, multiLine);
 	}
 
-	updateImportAttributes(node: ts.ImportAttributes, elements: ts.NodeArray<ts.ImportAttribute>, multiLine?: boolean): ts.ImportAttributes {
+	updateImportAttributes(
+		node: ts.ImportAttributes,
+		elements: ts.NodeArray<ts.ImportAttribute>,
+		multiLine?: boolean
+	): ts.ImportAttributes {
 		return ts.factory.updateImportAttributes(node, elements, multiLine);
 	}
 
@@ -95,10 +121,22 @@ export class CodeFactory {
 
 	// Additional methods to cover common usages in NodeClassFactory.ts
 
-	createImportDeclaration(moduleSpecifier: string, namedImports: string[], isTypeOnly = false, importAttributes?: ts.ImportAttributes, ...modifierFlags: ModifierFlags[]): ts.ImportDeclaration {
+	createImportDeclaration(
+		moduleSpecifier: string,
+		namedImports: string[],
+		isTypeOnly = false,
+		importAttributes?: ts.ImportAttributes,
+		...modifierFlags: ModifierFlags[]
+	): ts.ImportDeclaration {
 		return ts.factory.createImportDeclaration(
 			this.createModifiers(...modifierFlags),
-			this.createImportClause(isTypeOnly, undefined, ts.factory.createNamedImports(namedImports.map((name) => ts.factory.createImportSpecifier(false, undefined, this.createIdentifier(name)!)))),
+			this.createImportClause(
+				isTypeOnly,
+				undefined,
+				ts.factory.createNamedImports(
+					namedImports.map(name => ts.factory.createImportSpecifier(false, undefined, this.createIdentifier(name)!))
+				)
+			),
 			ts.factory.createStringLiteral(moduleSpecifier),
 			importAttributes
 		);
@@ -118,8 +156,18 @@ export class CodeFactory {
 		return ts.factory.createTypeAliasDeclaration(undefined, this.createIdentifier(name)!, undefined, type);
 	}
 
-	createClassDeclaration(name: string, members: ts.ClassElement[], heritageClauses?: ts.HeritageClause[]): ts.ClassDeclaration {
-		return ts.factory.createClassDeclaration(this.createModifiers(ts.ModifierFlags.Export), this.createIdentifier(name)!, undefined, heritageClauses, members);
+	createClassDeclaration(
+		name: string,
+		members: ts.ClassElement[],
+		heritageClauses?: ts.HeritageClause[]
+	): ts.ClassDeclaration {
+		return ts.factory.createClassDeclaration(
+			this.createModifiers(ts.ModifierFlags.Export),
+			this.createIdentifier(name)!,
+			undefined,
+			heritageClauses,
+			members
+		);
 	}
 
 	and<T>(...flags: T[]): T {
@@ -142,7 +190,12 @@ export class CodeFactory {
 		return ts.factory.createModifiersFromModifierFlags(this.or(...flags));
 	}
 
-	createMethodDeclaration(name: string, parameters: ts.ParameterDeclaration[], body: ts.Block, isAsync = false): ts.MethodDeclaration {
+	createMethodDeclaration(
+		name: string,
+		parameters: ts.ParameterDeclaration[],
+		body: ts.Block,
+		isAsync = false
+	): ts.MethodDeclaration {
 		return ts.factory.createMethodDeclaration(
 			isAsync ? this.createModifiers(ts.ModifierFlags.Async) : undefined,
 			undefined,
@@ -155,23 +208,51 @@ export class CodeFactory {
 		);
 	}
 
-	createPropertyDeclaration(name: string, initializer: ts.Expression, modifiers: ts.Modifier[] = []): ts.PropertyDeclaration {
-		return ts.factory.createPropertyDeclaration(modifiers, this.createIdentifier(name)!, undefined, undefined, initializer);
+	createPropertyDeclaration(
+		name: string,
+		initializer: ts.Expression,
+		modifiers: ts.Modifier[] = []
+	): ts.PropertyDeclaration {
+		return ts.factory.createPropertyDeclaration(
+			modifiers,
+			this.createIdentifier(name)!,
+			undefined,
+			undefined,
+			initializer
+		);
 	}
 
 	createConstructorDeclaration(parameters: ts.ParameterDeclaration[], body: ts.Block): ts.ConstructorDeclaration {
 		return ts.factory.createConstructorDeclaration(undefined, parameters, body);
 	}
 
-	createFunctionDeclaration(name: string, parameters: ts.ParameterDeclaration[], body: ts.Block, returnType?: ts.TypeNode): ts.FunctionDeclaration {
-		return ts.factory.createFunctionDeclaration([this.createModifier(ts.SyntaxKind.ExportKeyword)], undefined, this.createIdentifier(name)!, undefined, parameters, returnType, body);
+	createFunctionDeclaration(
+		name: string,
+		parameters: ts.ParameterDeclaration[],
+		body: ts.Block,
+		returnType?: ts.TypeNode
+	): ts.FunctionDeclaration {
+		return ts.factory.createFunctionDeclaration(
+			[this.createModifier(ts.SyntaxKind.ExportKeyword)],
+			undefined,
+			this.createIdentifier(name)!,
+			undefined,
+			parameters,
+			returnType,
+			body
+		);
 	}
 	createModifier(ExportKeyword: ts.ModifierSyntaxKind): ts.ModifierLike {
 		return ts.factory.createModifier(ExportKeyword);
 	}
 
 	createModuleDeclaration(name: string, body: ts.ModuleBlock, ...modifierFlags: ModifierFlags[]): ts.ModuleDeclaration {
-		return ts.factory.createModuleDeclaration(this.createModifiers(...modifierFlags), this.createIdentifier(name)!, body, ts.NodeFlags.Namespace);
+		return ts.factory.createModuleDeclaration(
+			this.createModifiers(...modifierFlags),
+			this.createIdentifier(name)!,
+			body,
+			ts.NodeFlags.Namespace
+		);
 	}
 
 	createToken<T extends ModifierSyntaxKind>(kind: T): ts.ModifierLike;
@@ -180,14 +261,31 @@ export class CodeFactory {
 		return ts.factory.createToken(kind);
 	}
 
-	createPropertySignature(name: string, type: ts.TypeNode, optional = false, ...modifiers: ModifierFlags[]): ts.PropertySignature {
-		return ts.factory.createPropertySignature(this.createModifiers(...modifiers), this.createIdentifier(name)!, optional ? this.createToken(ts.SyntaxKind.QuestionToken) : undefined, type);
+	createPropertySignature(
+		name: string,
+		type: ts.TypeNode,
+		optional = false,
+		...modifiers: ModifierFlags[]
+	): ts.PropertySignature {
+		return ts.factory.createPropertySignature(
+			this.createModifiers(...modifiers),
+			this.createIdentifier(name)!,
+			optional ? this.createToken(ts.SyntaxKind.QuestionToken) : undefined,
+			type
+		);
 	}
 	createTypeReferenceNode(typeName: string, qualifier: string): ts.TypeReferenceNode;
 	createTypeReferenceNode(typeName: string, ...typeArguments: ts.TypeNode[]): ts.TypeReferenceNode;
-	createTypeReferenceNode(typeName: string, qualifier?: string | ts.TypeNode, ...typeArguments: ts.TypeNode[]): ts.TypeReferenceNode {
+	createTypeReferenceNode(
+		typeName: string,
+		qualifier?: string | ts.TypeNode,
+		...typeArguments: ts.TypeNode[]
+	): ts.TypeReferenceNode {
 		if (typeof qualifier === 'string') {
-			return ts.factory.createTypeReferenceNode(ts.factory.createQualifiedName(this.createIdentifier(qualifier), this.createIdentifier(typeName)!), typeArguments);
+			return ts.factory.createTypeReferenceNode(
+				ts.factory.createQualifiedName(this.createIdentifier(qualifier), this.createIdentifier(typeName)!),
+				typeArguments
+			);
 		} else {
 			return ts.factory.createTypeReferenceNode(this.createIdentifier(typeName)!, [qualifier, ...typeArguments]);
 		}
@@ -209,8 +307,11 @@ 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)
-		{
+		if (
+			a.kind === ts.SyntaxKind.NumberKeyword ||
+			a.kind === ts.SyntaxKind.StringKeyword ||
+			a.kind === ts.SyntaxKind.BigIntKeyword
+		) {
 			return a.kind === b.kind;
 		}
 		return false;
@@ -232,10 +333,9 @@ export class CodeFactory {
 		}
 		catch(e)
 		{*/
-			//console.warn(e);
-			return ts.factory.createUnionTypeNode(t);
+		//console.warn(e);
+		return ts.factory.createUnionTypeNode(t);
 		//}
-
 	}
 
 	createIntersectionTypeNode(types: ts.TypeNode[]): ts.IntersectionTypeNode {
@@ -246,19 +346,39 @@ export class CodeFactory {
 		return ts.factory.createTypeLiteralNode(members);
 	}
 
-	createFunctionTypeNode(type: ts.TypeNode, typeParameters: readonly ts.TypeParameterDeclaration[], ...parameters: ts.ParameterDeclaration[]): ts.FunctionTypeNode {
+	createFunctionTypeNode(
+		type: ts.TypeNode,
+		typeParameters: readonly ts.TypeParameterDeclaration[],
+		...parameters: ts.ParameterDeclaration[]
+	): ts.FunctionTypeNode {
 		return ts.factory.createFunctionTypeNode(typeParameters, parameters, type);
 	}
 
-	createParameter(name: string, type: ts.TypeNode, initializer?: ts.Expression, optional = false): ts.ParameterDeclaration {
-		return ts.factory.createParameterDeclaration(undefined, undefined, this.createIdentifier(name)!, optional ? this.createToken(ts.SyntaxKind.QuestionToken) : undefined, type, initializer);
+	createParameter(
+		name: string,
+		type: ts.TypeNode,
+		initializer?: ts.Expression,
+		optional = false
+	): ts.ParameterDeclaration {
+		return ts.factory.createParameterDeclaration(
+			undefined,
+			undefined,
+			this.createIdentifier(name)!,
+			optional ? this.createToken(ts.SyntaxKind.QuestionToken) : undefined,
+			type,
+			initializer
+		);
 	}
 
 	createExpressionStatement(expression: ts.Expression): ts.ExpressionStatement {
 		return ts.factory.createExpressionStatement(expression);
 	}
 
-	createCallExpression(expression: ts.Expression, typeArguments: ts.TypeNode[] | undefined, argumentsArray: ts.Expression[]): ts.CallExpression {
+	createCallExpression(
+		expression: ts.Expression,
+		typeArguments: ts.TypeNode[] | undefined,
+		argumentsArray: ts.Expression[]
+	): ts.CallExpression {
 		return ts.factory.createCallExpression(expression, typeArguments, argumentsArray);
 	}
 
@@ -266,7 +386,11 @@ export class CodeFactory {
 		return ts.factory.createReturnStatement(expression);
 	}
 
-	createNewExpression(expression: ts.Expression, typeArguments: ts.TypeNode[] | undefined, argumentsArray: ts.Expression[]): ts.NewExpression {
+	createNewExpression(
+		expression: ts.Expression,
+		typeArguments: ts.TypeNode[] | undefined,
+		argumentsArray: ts.Expression[]
+	): ts.NewExpression {
 		return ts.factory.createNewExpression(expression, typeArguments, argumentsArray);
 	}
 
@@ -278,8 +402,15 @@ export class CodeFactory {
 		return ts.factory.createPropertyAssignment(this.createIdentifier(name)!, initializer);
 	}
 
-	createQualifiedName(left: ts.EntityName, right: string): ts.QualifiedName {
-		return ts.factory.createQualifiedName(left, this.createIdentifier(right)!);
+	createQualifiedName(...names: (ts.EntityName | string)[]): ts.EntityName {
+		let n = names.pop();
+		if (!n) throw new Error('No names provided');
+		let name = typeof n === 'string' ? this.createIdentifier(n) : n;
+		if (names.length === 0) {
+			return name;
+		} else {
+			return ts.factory.createQualifiedName(this.createQualifiedName(...names), name as ts.Identifier);
+		}
 	}
 
 	createLiteralTypeNode(literal: string | number): ts.LiteralTypeNode {
@@ -290,7 +421,7 @@ export class CodeFactory {
 		return ts.factory.createLiteralTypeNode(this.createStringLiteral(literal));
 	}
 
-	createLiteral(value: string | number): ts.LiteralExpression {
+	createLiteral(value: string | number): ts.LiteralExpression | ts.PrefixUnaryExpression {
 		if (typeof value === 'number') {
 			return this.createNumericLiteral(value as number);
 		}
@@ -298,7 +429,13 @@ export class CodeFactory {
 		return this.createStringLiteral(value);
 	}
 
-	createNumericLiteral(value: number, flags?: ts.TokenFlags): ts.NumericLiteral {
+	createNumericLiteral(value: number, flags?: ts.TokenFlags): ts.NumericLiteral | ts.PrefixUnaryExpression {
+		if (value < 0) {
+			return ts.factory.createPrefixUnaryExpression(
+				SyntaxKind.MinusToken,
+				ts.factory.createNumericLiteral((-value).toString(), flags)
+			);
+		}
 		return ts.factory.createNumericLiteral(value.toString(), flags);
 	}
 
@@ -322,32 +459,50 @@ export class CodeFactory {
 		return ts.factory.createPropertyAccessExpression(expression, name);
 	}
 
-	createHeritageClause(token: ts.SyntaxKind.ExtendsKeyword | ts.SyntaxKind.ImplementsKeyword, ...types: ts.ExpressionWithTypeArguments[]): ts.HeritageClause {
+	createHeritageClause(
+		token: ts.SyntaxKind.ExtendsKeyword | ts.SyntaxKind.ImplementsKeyword,
+		...types: ts.ExpressionWithTypeArguments[]
+	): ts.HeritageClause {
 		return ts.factory.createHeritageClause(token, types);
 	}
 
-	createExpressionWithTypeArguments(expression: ts.Expression, ...typeArguments: ts.TypeNode[]): ts.ExpressionWithTypeArguments {
+	createExpressionWithTypeArguments(
+		expression: ts.Expression,
+		...typeArguments: ts.TypeNode[]
+	): ts.ExpressionWithTypeArguments {
 		return ts.factory.createExpressionWithTypeArguments(expression, typeArguments);
 	}
 	createBlock(multiLine: boolean, ...statements: ts.Statement[]): ts.Block;
 	createBlock(...statements: ts.Statement[]);
 	createBlock(multiLine: boolean | ts.Statement, ...statements: ts.Statement[]): ts.Block {
-		if(typeof multiLine === 'boolean') {
+		if (typeof multiLine === 'boolean') {
 			return ts.factory.createBlock(statements, multiLine);
 		}
-		return ts.factory.createBlock([multiLine, ...statements],true);
-
+		return ts.factory.createBlock([multiLine, ...statements], true);
 	}
 
-	createModuleBlock(statements: ts.Statement[]): ts.ModuleBlock {
+	createModuleBlock(...statements: ts.Statement[]): ts.ModuleBlock {
 		return ts.factory.createModuleBlock(statements);
 	}
 
-	createInterfaceDeclaration(name: string, members: ts.TypeElement[], heritageClauses?: ts.HeritageClause[]): ts.InterfaceDeclaration {
-		return ts.factory.createInterfaceDeclaration([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], this.createIdentifier(name)!, undefined, heritageClauses, members);
+	createInterfaceDeclaration(
+		name: string,
+		members: ts.TypeElement[],
+		heritageClauses?: ts.HeritageClause[]
+	): ts.InterfaceDeclaration {
+		return ts.factory.createInterfaceDeclaration(
+			[ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+			this.createIdentifier(name)!,
+			undefined,
+			heritageClauses,
+			members
+		);
 	}
 
-	createTypeOperatorNode(operator: ts.SyntaxKind.KeyOfKeyword | ts.SyntaxKind.ReadonlyKeyword | ts.SyntaxKind.UniqueKeyword, type: ts.TypeNode): ts.TypeOperatorNode {
+	createTypeOperatorNode(
+		operator: ts.SyntaxKind.KeyOfKeyword | ts.SyntaxKind.ReadonlyKeyword | ts.SyntaxKind.UniqueKeyword,
+		type: ts.TypeNode
+	): ts.TypeOperatorNode {
 		return ts.factory.createTypeOperatorNode(operator, type);
 	}
 
@@ -359,7 +514,15 @@ export class CodeFactory {
 		return ts.factory.createAsExpression(expression, type);
 	}
 
-	createPropertyAccessChain(name: string, useQuestionDot: boolean = true, expression: ts.Expression): ts.PropertyAccessChain {
-		return ts.factory.createPropertyAccessChain(expression, useQuestionDot ? this.createToken(ts.SyntaxKind.QuestionDotToken) : undefined, this.createIdentifier(name)!);
+	createPropertyAccessChain(
+		name: string,
+		useQuestionDot: boolean = true,
+		expression: ts.Expression
+	): ts.PropertyAccessChain {
+		return ts.factory.createPropertyAccessChain(
+			expression,
+			useQuestionDot ? this.createToken(ts.SyntaxKind.QuestionDotToken) : undefined,
+			this.createIdentifier(name)!
+		);
 	}
 }