isy-nodejs 1.0.1-alpha.6 → 1.0.2-alpha.0

package/package.json

@@ -2,7 +2,7 @@
     "name": "isy-nodejs",
     "description": "Node.js wrapper for ISY interface including websockets for change notifications. Fork of isy-js by Rod Toll. Designed to be used in a node.js application.",
     "license": "MIT",
-    "version": "1.0.1-alpha.6",
+    "version": "1.0.2-alpha.0",
     "author": {
         "name": "Pradeep Mouli"
     },
@@ -13,7 +13,7 @@
         "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 && npm run build:cjs",
+        "build": "npm run build:esm",
         "build:esm:watch": "tsc -p ./tsconfig.esm.json --watch"
     },
     "keywords": [
@@ -52,26 +52,23 @@
     },
     "dependencies": {
         "@log4js-node/log4js-api": "^1.0.2",
-        "@project-chip/matter-node.js": "^0.10.6",
-        "@project-chip/matter.js": "^0.10.6",
+        "@matter/general": "^0.11.4",
+        "@matter/types": "^0.11.4",
+        "@project-chip/matter-node.js": "^0.11.4",
+        "@project-chip/matter.js": "^0.11.4",
         "axios": "^1.7.7",
         "fast-xml-parser": "^4.5.0",
         "faye-websocket": "^0.11.4",
-        "install": "^0.13.0",
-        "mocha": "^10.7.3",
+        "mocha": "^10.8.2",
         "p-queue": "^8.0.1",
-        "winston": "^3.15.0",
+        "winston": "^3.17.0",
         "xml2js": "^0.6.2"
     },
     "bugs": {
-        "url": "https://github.com/pradeepmouli/isy-nodejs/issues"
-    },
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/pradeepmouli/isy-js.git"
+        "url": "https://github.com/pradeepmouli/udi-js/issues"
     },
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "960151429615c48f5774a0911ca58885a39e55b4"
+    "gitHead": "1c92bb07bb652f73334bf200841ab4a10f562965"
 }

package/src/CodeGeneration/EnumFactory.ts

@@ -1,7 +1,7 @@
 import { factory } from "typescript";
 import { createWrappedNode, ts, type EnumDeclaration, EnumMember, Identifier } from 'ts-morph'
 import { UnitOfMeasure } from "../Definitions/Global/UOM.js";
-import { Family } from "../ISY.js";
+
 import type {
   NodeClassDefinition,
   DriverDefinition,
@@ -12,6 +12,7 @@ import { EnumDefinition, EnumDefinitionMap } from "../Model/EnumDefinition.js";
 import { isGeneratorFunction } from "util/types";
 import { Logger, loggers } from "winston";
 import { pascalCase } from 'moderndash';
+import { Family } from '../Definitions/index.js';
 
 
 const logger = loggers.get("EnumFactory");

package/src/CodeGeneration/NodeClassFactory.ts

@@ -2,9 +2,10 @@ import { createWrappedNode, IndentationText, Project, QuoteKind, SourceFile, ts,
 import { factory, Statement, type Declaration } from 'typescript';
 import type { Driver } from '../Definitions/Global/Drivers.js';
 import { UnitOfMeasure } from '../Definitions/Global/UOM.js';
-import { Family } from '../ISY.js';
+
 import { CommandDefinition, DataTypeDefinition, DriverDefinition, NodeClassDefinition, ParameterDefinition } from '../Model/ClassDefinition.js';
 import { EnumDefinitionMap } from '../Model/EnumDefinition.js';
+import  { Family } from '../Definitions/index.js';
 
 // #region Type aliases (1)
 

package/src/Converters.ts

@@ -1,87 +1,159 @@
-import { UnitOfMeasure } from "./Definitions/Global/UOM.js";
-import { Converter, invert } from './Utils.js';
+import { UnitOfMeasure } from './Definitions/Global/UOM.js';
+import { type StringKeys } from './Utils.js';
 
 let BooleanPercentage: Converter<boolean, number>;
+let NullConverter: Converter<any, any>;
+{
+	to: (value: any) => value;
+	from: (value: any) => value;
+}
 
-BooleanPercentage = {
-  to: (value: number): boolean => {
-    return value > 0;
-  },
-  from: (value: boolean): number => {
-    return value ? 100 : 0;
-  },
+const StandardConverters = {
+	Boolean: {
+		LevelFrom0To255: {
+			to: (value: boolean) => (value ? 255 : 0),
+			from: (value: number) => value > 0
+		},
+		Percent: {
+			to: (value: number): boolean => {
+				return value > 0;
+			},
+			from: (value: boolean): number => {
+				return value ? 100 : 0;
+			}
+		}
+	},
+	LevelFrom0To255: {
+		Percent: {
+			to: (value: number): number => {
+				return Math.round((value * 100) / 255);
+			},
+			from: (value: number): number => {
+				return Math.round((value * 255) / 100);
+			}
+		}
+	}
 };
 
-const StandardConverters : {
-    [x in `${keyof typeof UnitOfMeasure}`]?: { [y in `${keyof typeof UnitOfMeasure}`]?: Converter<any, any> };
-  }  = {
-  Boolean: {
-    LevelFrom0To255: {
-      from: (value: number) => value > 0,
-      to: (value: boolean) => (value ? 255 : 0),
-    },
-    Percent: BooleanPercentage,
-  },
-  Percent: {},
-  LevelFrom0To255: {
-    Percent: {
-      to: (value: number): number => {
-        return Math.round((value * 255) / 100);
-      },
-      from: (value: number): number => {
-        return Math.round((value * 100) / 255);
-      },
-    },
-  },
-};
+//StandardConverters.Percent.LevelFrom0To255 = invert(StandardConverters.LevelFrom0To255.Percent);
+//StandardConverters.LevelFrom0To255.Boolean = invert(StandardConverters.Boolean.LevelFrom0To255);
 
-StandardConverters.Percent.LevelFrom0To255 = invert(StandardConverters.LevelFrom0To255.Percent);
-StandardConverters.LevelFrom0To255.Boolean = invert(StandardConverters.Boolean.LevelFrom0To255);
+export const StdConverterRegistry = new Map<UnitOfMeasure | string, Map<UnitOfMeasure | string, Converter<any, any>>>();
 
-export const ConverterRegistry = new Map<UnitOfMeasure, Map<UnitOfMeasure, Converter<any, any>>>();
+export const ConverterRegistry = new Map<string, Converter<any, any>>();
 
-function registerConverters(){
-  for (const from in StandardConverters) {
-    for (const to in StandardConverters[from]) {
-      registerConverter(UnitOfMeasure[from], UnitOfMeasure[to], StandardConverters[from][to] as Converter<any, any>);
-    }
-  }
+function registerConverters() {
+	for (const from in StandardConverters) {
+		for (const to in StandardConverters[from]) {
+			registerConverter(from, to, StandardConverters[from][to] as Converter<any, any>);
+			registerConverter(to, from, invert(StandardConverters[from][to]) as Converter<any, any>);
+		}
+	}
+	for (const from in Converter.Matter) {
+		for (const to in Converter.Matter[from]) {
+			registerConverter(from, to, Converter.Matter[from][to] as Converter<any, any>);
+			registerConverter(to, from, invert(Converter.Matter[from][to]) as Converter<any, any>);
+		}
+	}
 }
 
-export function registerConverter(from: UnitOfMeasure, to: UnitOfMeasure, converter: Converter<any, any>)
-{
-  if (!ConverterRegistry.has(from)) {
-    ConverterRegistry.set(from, new Map());
-  }
-  ConverterRegistry.get(from).set(to, converter);
+export function registerConverter(
+	from: keyof typeof StandardConverters | keyof typeof Converter.Matter | string,
+	to: keyof typeof StandardConverters | keyof typeof Converter.Matter | string,
+	converter: Converter<any, any>
+) {
+	if (!StdConverterRegistry.has(from)) {
+		StdConverterRegistry.set(from, new Map());
+	}
+
+	StdConverterRegistry.get(from).set(to, converter);
+	let key = from + '.' + to;
+	if (!ConverterRegistry.has(key)) {
+		ConverterRegistry.set(key, converter);
+	}
 }
 
-export namespace Converters {
-  export const Standard : typeof StandardConverters = StandardConverters;
-
-  export const Matter: { [x in `${keyof typeof UnitOfMeasure}`]?: { [y: string]: Converter<any, any> } } = {
-    LevelFrom0To255: {
-      LightingLevel: {
-        from: (value) => (value === 1 ? 0 : value === 254 ? 255 : value),
-        to: (value) => (value === 0 ? 1 : value === 255 ? 254 : value),
-      },
-    }
-  };
-
-  export function getConverter(from: UnitOfMeasure, to: UnitOfMeasure): Converter<any, any> {
-    if (!ConverterRegistry.has(from)) {
-      return null;
-    }
-    return ConverterRegistry.get(from).get(to);
-  }
-
-  export function convert<F,T>(from: UnitOfMeasure, to: UnitOfMeasure, value: F): T {
-    const converter = getConverter(from, to);
-    if (converter) {
-      return converter.to(value);
-    }
-    return null;
-  }
+export namespace Converter {
+	export const Standard: typeof StandardConverters = StandardConverters;
+
+	export const Matter = {
+		LevelFrom0To255: {
+			LightingLevel: {
+				from: (value) =>
+					value === 1 ? 0
+					: value === 254 ? 255
+					: value,
+				to: (value) =>
+					value === 0 ? 1
+					: value === 255 ? 254
+					: value
+			}
+
+		}
+	};
+
+	export type ConverterTypes = `${StringKeys<typeof StandardConverters>}`;
+
+	export type StandardConverters = `${StringKeys<typeof StandardConverters>}.${StringKeys<typeof StandardConverters>}`;
+
+	export type MatterISYConvertibleTypes = `${StringKeys<(typeof Matter)[`${keyof typeof Matter}`]>}`;
+
+	export type ISYMatterConvertibleTypes = `${StringKeys<typeof Matter>}`;
+
+	export type MatterConverters = `${MatterISYConvertibleTypes}.${ISYMatterConvertibleTypes}` | `${ISYMatterConvertibleTypes}.${MatterISYConvertibleTypes}`;
+
+	export type KnownConverters = StandardConverters | MatterConverters;
+	const cache: { [x: string]: Converter<any, any> } = {};
+	export function get(label: KnownConverters): Converter<any, any>;
+	export function get(from: UnitOfMeasure, to: UnitOfMeasure);
+	export function get(from: ConverterTypes, to: ConverterTypes);
+	export function get(from: UnitOfMeasure, to: UnitOfMeasure);
+	export function get(from: MatterISYConvertibleTypes, to: ISYMatterConvertibleTypes);
+	export function get(to: ISYMatterConvertibleTypes, from: MatterISYConvertibleTypes);
+	export function get(from: UnitOfMeasure | `${keyof typeof UnitOfMeasure}` | string, to?: UnitOfMeasure | `${keyof typeof UnitOfMeasure}` | string): Converter<any, any> {
+		if (to === undefined) {
+			return ConverterRegistry.get(from as string) ?? NullConverter;
+		}
+		if (cache[`${from}.${to}`]) {
+			return cache[`${from}.${to}`];
+		} else if (cache[`${to}.${from}`]) {
+			cache[`${from}.${to}`] = invert(cache[`${to}.${from}`]);
+			return cache[`${from}.${to}`];
+		}
+		let isString = typeof from === 'string';
+		let fuom = isString ? from : UnitOfMeasure[from];
+		if (to) {
+			let tuom = typeof to === 'string' ? to : UnitOfMeasure[to];
+
+			if (StdConverterRegistry.has(fuom)) {
+				if (StdConverterRegistry.get(fuom).has(tuom)) {
+					return StdConverterRegistry.get(fuom).get(tuom);
+				}
+			}
+		}
+		return NullConverter;
+	}
+
+	export function convert<F, T>(from: UnitOfMeasure, to: UnitOfMeasure, value: F): T {
+		const converter = get(from, to);
+		if (converter) {
+			return converter.to(value);
+		}
+		return null;
+	}
 }
 
-registerConverters();
+registerConverters();
+export interface Converter<F, T> {
+	// #region Properties (2)
+	from: (value: F) => T;
+	to: (value: T) => F;
+} //onst D: d = 'ST';
+//type DriverLabel = Values<IdentityOf<DriverType>>;
+
+export function invert<F, T>(converter: Converter<F, T>): Converter<T, F> {
+	return {
+		from: converter.to,
+		to: converter.from
+	};
+}

package/src/Definitions/Global/Commands.ts

@@ -1,35 +1,153 @@
-import { TimeFormatLocalization } from '@project-chip/matter.js/cluster';
-import type { Identity, Merge, UnionToIntersection } from '@project-chip/matter.js/util';
-import type { Sign } from 'crypto';
+import { Converter } from '../../Converters.js';
+import type { ISYNode } from '../../ISYNode.js';
+import type { Driver } from './Drivers.js';
+import type { UnitOfMeasure } from './UOM.js';
+
+/*export class Command<T extends string> extends Function {
+
+	constructor(public readonly label: string) {
+		super();
+	}
+
+	public async execute(...args: any[]): Promise<Boolean> {
+		return this(...args);
+	}
+}*/
+
+export interface Parameter<P, T> {
+	id: P;
+	name: string;
+
+	label: string;
+	value?: T;
+	uom: UnitOfMeasure;
+	serverUom?: UnitOfMeasure;
+
+	converter?: (value: T) => T;
+
+	driver: string;
+}
+
+
+
+type ParameterCollection = { [K: string]: Parameter<typeof K, any> };
+
+
+function isParameterCollection(value: any): value is ParameterCollection {
+	return value !== undefined && value.name === undefined;
+}
+
+export type Command<C extends string, N = C, L = N, P extends { [K: string]: Parameter<typeof K, any> } | Parameter<string,any> = null> =
+	P extends null ? { id: C; label: L; name: N }
+	: P extends Parameter<string,any> ? {id: C; label: L; name: N; uom: P['uom']; serverUom?: P['serverUom']; converter?: (value: P['value']) => P['value']; driver: P['driver']} : P extends ParameterCollection ?
+	 {
+			// #region Properties (8)
+
+			(params: { [x in keyof P]: P[x]["value"] }): Promise<boolean>;
+			id: C;
+			label: L;
+			name: N;
+			parameters: P;
+
+			// #endregion Properties (8)
+
+			// #region Public Methods (2)
+
+			// #endregion Public Methods (2)
+			//override on('change', listener: (value: any) => void): this;
+		} : never;
 
 export namespace Command {
+	export type Signature<F extends { name } = CallableFunction, L extends string = string, N extends string = string> = F & { label: L; name: N };
+
+	export type Signatures<C extends string> = { [K in C]: Signature<(...args: any[]) => Promise<Boolean>, string, string> };
+
+	export type NoExtraKeys<U> = U extends infer F ? F : never;
+
+	export type NoExtend<F, T> = F extends T ? F : never;
+
+	export type For<N extends string, L extends string, T> = T extends Signature<infer F, L, N> ? F : T;
 
-    export type Signature<F extends {name: string} = CallableFunction, L extends string = string,N extends string = string> = F & {label: L, name: N };
+	//type test2 = ForAll<Signatures<"BEEP">>
 
-    export type Signatures<C extends string> = {[K in C]: Signature<(...args: any[]) => Promise<Boolean>, string, string>};
+	//extends CallableFunction ? Omit<T, "label"| "name"> | T : never;
+	type test = For<'beep', 'Beep', Commands['BEEP']>;
 
-    export type NoExtraKeys<U> = U extends infer F ? F : never;
+	//type test2 = keyof Commands["BEEP"]
 
-    export type NoExtend<F,T> = F extends T ? F : never;
+	export type ForAll<T extends Signatures<any>> = {
+		[K in keyof T]: For<T[K]['name'], T[K]['label'], T[K]>;
+	};
 
-    export type For<N extends string, L extends string, T> = T extends Signature<infer F, L, N> ? F : T;
 
-    //type test2 = ForAll<Signatures<"BEEP">>
 
-    //extends CallableFunction ? Omit<T, "label"| "name"> | T : never;
-    type test = For<"beep","Beep",Commands["BEEP"]>
+	function getCommandFunctionSignature<P extends { [x: string]: Parameter<string, any> } | Parameter<string, any> | null> (command: string, node: ISYNode<any,any,any,any>,parameters?: P): Function {
+		if (parameters === null) {
+			return function (): Promise<boolean> {
+				return node.sendCommand(command);
+			};
+		}
 
-    //type test2 = keyof Commands["BEEP"]
+		else if (isParameterCollection(parameters)) {
+			let cmd = function (params: { [x in keyof P]: typeof parameters[x]['value'] }): Promise<boolean> {
+				for (let key in params) {
+					let p = parameters[key];
+					if (p.converter) {
+						params[key] = p.converter(params[key]);
+					}
+				}
+				return node.sendCommand(command, params);
+			} as any;
+			for (let key in parameters) {
+				let p = parameters[key];
+				cmd.parameters[key] = p;
+				let srvUom = node.drivers[p.driver]?.serverUom;
+				if (node.drivers[parameters[key].driver]?.serverUom) {
+					cmd.parameters[key].serverUom = node.drivers[parameters[key].driver].serverUom;
+					if (srvUom) {
+						cmd.parameters[key].converter = Converter.get(p.uom, srvUom).to;
+						cmd.parameters[key].serverUom = srvUom;
+					}
+				}
+			}
+			return cmd;
+		}
+		else if(parameters.name) {
+			let cmd = function (value: P['value']): Promise<boolean> {
+				if(parameters.converter) {
+					value = parameters.converter(value);
+				}
+				return node.sendCommand(command, { value: value });
+			} as any
+			let srvUom = node.drivers[parameters.driver]?.serverUom;
+			if (srvUom) {
+				cmd.serverUom = srvUom;
+				cmd.converter = Converter.get(parameters.uom, srvUom).to;
+			}
+			cmd.uom = parameters.uom;
+			return cmd;
+		}
 
-    export type ForAll<T extends Signatures<any>> = {
-      [K in keyof T]: For<T[K]["name"],T[K]["label"],T[K]>
+	}
 
-    };
+	export function create<
+		C extends string,
+		N = string,
+		L = string,
+		P extends ParameterCollection | Parameter<any,any> | null = null
+	>(command: C, node: ISYNode<any, any, any, any>, label: L, name: N, parameters: P = null): Command<C, N, L, P> {
 
-   type Commands = {
-    BEEP: ((value: number) => Promise<boolean>) & {label: "Beep", name: "beep"};
-    BL:((value: number) => Promise<boolean>) & {label: "Backlight", name: "backlight"};
-    WDU: (() => Promise<boolean>) & {label: "Backlight", name: "backlight"};
-   }
+		let cmd: Command<C, N, L, P> =
+		getCommandFunctionSignature(command, node, parameters) as Command<C, N, L, P>;
+		cmd.label = label;
+		cmd.name = name;
+		cmd.id = command;
+		return cmd;
+	}
 
-};
+	type Commands = {
+		BEEP: ((value: number) => Promise<boolean>) & { label: 'Beep'; name: 'beep' };
+		BL: ((value: number) => Promise<boolean>) & { label: 'Backlight'; name: 'backlight' };
+		WDU: (() => Promise<boolean>) & { label: 'Backlight'; name: 'backlight' };
+	};
+}

package/src/Definitions/Global/Drivers.ts

@@ -3,15 +3,12 @@ import { isBoxedPrimitive } from 'util/types';
 import type { ISYNode } from '../../ISYNode.js';
 import { UnitOfMeasure } from './UOM.js';
 
-import { KeyType } from '@project-chip/matter.js/crypto';
-import type { TlvNumberSchema } from '@project-chip/matter.js/tlv';
-import type { Identity, MaybePromise, UnionToIntersection } from '@project-chip/matter.js/util';
-import exp from 'constants';
-import { init } from 'homebridge';
+import type { Identity, MaybePromise, UnionToIntersection } from '@matter/general';
 import { server } from 'typescript';
+import { Converter } from '../../Converters.js';
 import type { ISYDeviceNode } from '../../Devices/ISYDeviceNode.js';
 import type { DriverState } from '../../Model/DriverState.js';
-import type { Converter, StringKeys } from '../../Utils.js';
+import type { StringKeys } from '../../Utils.js';
 import type { Family } from './Families.js';
 
 export enum DriverType {
@@ -293,10 +290,10 @@ export interface Driver<
 	// #region Public Methods (2)
 
 	apply(state: DriverState, notify?: boolean): boolean;
-	patch(value: T, formattedValue: string, uom: UnitOfMeasure, prec: number): boolean;
+	patch(value: T, formattedValue: string, uom: UnitOfMeasure, prec: number, notify?: boolean): boolean;
 
 	// #endregion Public Methods (2)
-//override on('change', listener: (value: any) => void): this;
+	//override on('change', listener: (value: any) => void): this;
 }
 
 export interface StatelessDriver<
@@ -326,7 +323,7 @@ export interface StatelessDriver<
 	uom: U;
 
 	// #endregion Properties (9)
-//override on('change', listener: (value: any) => void): this;
+	//override on('change', listener: (value: any) => void): this;
 }
 
 export function isStateless(x: any): x is StatelessDriver<any, any, any> {
@@ -339,7 +336,6 @@ export function isTrue(x: true | false): x is true {
 
 export type DriverTypeLiteral = EnumLiteral<DriverType>;
 
-
 export type EnumWithLiteral<D extends string | bigint | number | boolean> = D | EnumLiteral<D>;
 export namespace Driver {
 	export type Signature<U extends UnitOfMeasure = UnitOfMeasure, V = any, SU = U, N = string, L = N> = { uom: U; value: V; name: N; label: L; serverUom?: SU };
@@ -384,7 +380,7 @@ export namespace Driver {
 	type StatelessOrStateful<D extends string, U extends UnitOfMeasure, T = number, N = string, L = string, S extends boolean = false> =
 		S extends true ? StatelessDriver<D, U, T, U, N, L> : Driver<D, U, T, U, N, L>;
 
-	export function create<D extends Literal, U extends UnitOfMeasure, T = number, L extends string = string, N extends string = string, S extends boolean = false>(
+	export function create<D extends Literal, U extends UnitOfMeasure, T = number, N extends string = string, L extends string = string, S extends boolean = false>(
 		driver: EnumWithLiteral<D>,
 
 		node?: ISYNode<Family, any, any, any>,
@@ -427,6 +423,7 @@ export namespace Driver {
 						converter ? converter.from(initState.value)
 						:	(node.convertFrom(initState?.value, initState?.uom, driver as D) as T)
 					:	null,
+				rawValue: initState ? initState.value : null,
 				formattedValue: initState ? initState.formatted : null,
 				pendingValue: null
 			},
@@ -437,27 +434,39 @@ export namespace Driver {
 				return s;
 			},
 			apply(state: DriverState, notify = false) {
-				let previousValue = this.state.value;
-				this.state.value = converter ? converter.from(state.value) : node.convertFrom(state.value, state.uom, driver as D);
-				this.state.formattedValue = state.formatted;
-				if (previousValue == this.state.value) {
+				let previousValue = this.state.rawValue;
+				this.state.rawValue = state.value;
+				if (previousValue === this.state.rawValue) {
 					return false;
 				}
+				if (state.uom != this.uom) {
+					this.serverUom == state.uom;
+					this.state.value = converter ? converter.from(this.state.rawValue) : Converter.convert(state.uom, this.uom, this.state.rawValue);
+				} else if (converter) {
+					this.state.value = converter.from(state.value);
+				} else {
+					this.state.value = state.value;
+				}
+				this.state.formattedValue = state.formatted;
 				if (notify) node.events.emit(`${this.name}Changed`, driver as D, this.state.value, previousValue, this.state.formattedValue);
 				return true;
 			},
-			patch(value: T, formattedValue: string, uom: UnitOfMeasure, prec: number, notify = false) {
-				let previousValue = this.state.value;
-
+			patch(value: T, formattedValue: string, uom: UnitOfMeasure, prec: number, notify = true) {
+				let previousValue = this.state.rawValue;
+				this.state.rawValue = value;
 				this.state.formattedValue = formattedValue;
 				if (uom != this.uom) {
-					this.serverUom = uom;
-					this.state.value = converter ? converter.from(value) : node.convertFrom(value, uom, driver as D);
+					this.serverUom == uom;
+					this.state.value = converter ? converter.from(this.state.rawValue) : Converter.convert(uom, this.uom, this.state.rawValue);
+				} else if (converter) {
+					this.state.value = converter.from(value);
+				} else {
+					this.state.value = value;
 				}
 				if (previousValue == this.state.value) {
 					return false;
 				}
-				if (notify) node.events.emit(`${this.name}Changed`, driver as D, value, previousValue, formattedValue);
+				if (notify) node.events.emit(`${this.name}Changed`, driver as D, this.state.value, previousValue, formattedValue);
 				return true;
 			},
 			get value() {

package/src/Definitions/Global/Events.ts

@@ -1,9 +1,9 @@
-import type { UnionToIntersection } from '@project-chip/matter.js/util';
+import type { UnionToIntersection } from '@matter/general';
 import type { AnyMxRecord } from 'dns';
 import EventEmitter, { on } from 'events';
 import type { EventType } from '../../Events/EventType.js';
 import { ISYEvent } from '../../Events/ISYEvent.js';
-import type { InsteonBaseDevice, ISY } from '../../ISY.js';
+import type { ISY } from '../../ISY.js';
 import type { ISYNode } from '../../ISYNode.js';
 import type { UnitOfMeasure } from './UOM.js';
 
@@ -52,7 +52,8 @@ export namespace Event {
 
 	constructor(node: N) {
 			super({ captureRejections: true });
-		}
+
+	}
 
 	// #endregion Constructors (1)
 }
@@ -61,8 +62,8 @@ export namespace Event {
 		node: N
 	): FunctionSigFor<E, NodeEventEmitter<N>> & Omit<NodeEventEmitter<N>, 'on'> {
 		var f = new NodeEventEmitter(node);
-		for (let evt in node.events) {
-			const ev = node.events[evt];
+		for (let evt in node.drivers) {
+
 			//f[`on${ev.name}`] = f.on.bind(f, ev.name);
 		}
 

package/src/Definitions/Global/UOM.ts

@@ -159,10 +159,15 @@ export function toString(this: UnitOfMeasure): keyof typeof UnitOfMeasure {
 	return UnitOfMeasure[this] as keyof typeof UnitOfMeasure;
 }
 
+
 //import { Converters } from "../../Converters.js";
 export namespace UnitOfMeasure {
 	export type ToType<X extends UnitOfMeasure> = X extends UnitOfMeasure.Boolean ? boolean : number;
 
+	export type Standard = keyof typeof UnitOfMeasure;
+
+	export type Matter = 'LightingLevel' | 'RampRate';
+
 	/*export function convertTo<X extends UnitOfMeasure, Y extends UnitOfMeasure>(
 		this: X,
 		targetUOM: Y,