isy-nodejs 1.0.1-alpha.9 → 1.0.2-alpha.1

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.9",
+    "version": "1.0.2-alpha.1",
     "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,21 +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"
+        "url": "https://github.com/pradeepmouli/udi-js/issues"
     },
     "publishConfig": {
         "access": "public"
-    }
+    },
+    "gitHead": "e8bc6294609ae4951cdf35bf1a7c926ef0ff5cd9"
 }

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,4 +1,3 @@
-
 import { UnitOfMeasure } from './Definitions/Global/UOM.js';
 import { type StringKeys } from './Utils.js';
 
@@ -9,26 +8,21 @@ let NullConverter: Converter<any, any>;
 	from: (value: any) => value;
 }
 
-BooleanPercentage = {
-	to: (value: number): boolean => {
-		return value > 0;
-	},
-	from: (value: boolean): number => {
-		return value ? 100 : 0;
-	}
-};
-
-const StandardConverters: {
-	[x in `${keyof typeof UnitOfMeasure}`]?: { [y in `${keyof typeof UnitOfMeasure}`]?: Converter<any, any> };
-} = {
+const StandardConverters = {
 	Boolean: {
 		LevelFrom0To255: {
 			to: (value: boolean) => (value ? 255 : 0),
 			from: (value: number) => value > 0
 		},
-		Percent: BooleanPercentage
+		Percent: {
+			to: (value: number): boolean => {
+				return value > 0;
+			},
+			from: (value: boolean): number => {
+				return value ? 100 : 0;
+			}
+		}
 	},
-	Percent: {},
 	LevelFrom0To255: {
 		Percent: {
 			to: (value: number): number => {
@@ -41,8 +35,8 @@ const StandardConverters: {
 	}
 };
 
-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>>>();
 
@@ -51,8 +45,8 @@ 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>);
-			registerConverter(UnitOfMeasure[to], UnitOfMeasure[from], invert(StandardConverters[from][to]) as Converter<any, any>);
+			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) {
@@ -64,8 +58,8 @@ function registerConverters() {
 }
 
 export function registerConverter(
-	from: keyof typeof StandardConverters | UnitOfMeasure | keyof typeof Converter.Matter | string,
-	to: keyof typeof StandardConverters | UnitOfMeasure | keyof typeof Converter.Matter | string,
+	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)) {
@@ -94,6 +88,7 @@ export namespace Converter {
 					: value === 255 ? 254
 					: value
 			}
+
 		}
 	};
 
@@ -108,7 +103,7 @@ export namespace Converter {
 	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);
@@ -116,16 +111,25 @@ export namespace Converter {
 	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 ? UnitOfMeasure[from] : from;
+		let fuom = isString ? from : UnitOfMeasure[from];
 		if (to) {
-			let tuom = typeof to === 'string' ? UnitOfMeasure[to] : to;
+			let tuom = typeof to === 'string' ? to : UnitOfMeasure[to];
 
 			if (StdConverterRegistry.has(fuom)) {
-				return StdConverterRegistry.get(fuom).get(tuom);
+				if (StdConverterRegistry.get(fuom).has(tuom)) {
+					return StdConverterRegistry.get(fuom).get(tuom);
+				}
 			}
-		} else if (typeof from === 'string') {
-			return ConverterRegistry.get(from);
 		}
 		return NullConverter;
 	}

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,11 +3,7 @@ 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';
@@ -297,7 +293,7 @@ export interface Driver<
 	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<
@@ -327,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> {
@@ -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,  N extends string = string, L 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,36 +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 = true) {
-				let previousValue = this.state.value;
-
+				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) : Converter.convert(uom, this.uom, value);
-
-				}
-				else if(converter)
-				{
+					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
-				{
+				} 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';
 
@@ -63,7 +63,7 @@ export namespace Event {
 	): FunctionSigFor<E, NodeEventEmitter<N>> & Omit<NodeEventEmitter<N>, 'on'> {
 		var f = new NodeEventEmitter(node);
 		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,

package/src/Devices/EndpointFor.ts

@@ -23,13 +23,15 @@ export type RelaxTypes<V> = V extends number
             : V;
 
 export type RelaxedClusterType = RelaxTypes<ClusterType>
-
+//@ts-ignore
 export type EndpointFor<K extends Behavior.Type, K1 extends Behavior.Type = K, K2 extends Behavior.Type = K, K3 extends Behavior.Type = K> = { events: SupportedBehaviors.EventsOf<SupportedBehaviors.MapOf<[K, K1, K2, K3]>>} & MutableEndpoint.With<EndpointType.Empty, SupportedBehaviors.MapOf<[K, K1, K2, K3]>>
 
 /*set: (values: SupportedBehaviors.StatePatchOf<SupportedBehaviors.MapOf<[K, K1, K2]>>) => void; }*/
 export type BehaviorsOf <K extends ClusterType.Of<ClusterType.Options<{}>>, K1 extends ClusterType = K, K2 extends ClusterType = K, K3 extends ClusterType = K> = [ClusterBehavior.Type<K>,ClusterBehavior.Type<K1>,ClusterBehavior.Type<K2>,ClusterBehavior.Type<K3>]
-
+//@ts-ignore
+//@ts-ignore
 export type SupportedBehaviorsOf <K extends ClusterType.Of<ClusterType.Options<{}>>, K1 extends ClusterType = K, K2 extends ClusterType = K, K3 extends ClusterType = K> =
+//@ts-ignore
 SupportedBehaviors.MapOf<BehaviorsOf<K, K1,K2,K3>>
 
 export type EndpointForCluster<K extends ClusterType.Of<ClusterType.Options<{}>>, K1 extends ClusterType = K, K2 extends ClusterType = K, K3 extends ClusterType = K> = { events: SupportedBehaviors.EventsOf<SupportedBehaviorsOf<K,K1,K2,K3>>; set: (values: SupportedBehaviors.StatePatchOf<SupportedBehaviorsOf<K, K1, K2,K3>>) => void; }
@@ -46,22 +48,22 @@ export const MatterEndpoint= <P extends EndpointType & MutableEndpoint, T extend
 
 
 		createEndpoint<K extends SupportedBehaviors>() : Endpoint {
-
+			//@ts-ignore
 			var p = this.endpointType.with(BridgedDeviceBasicInformationServer);
 
-		 	const id = this.address.replaceAll(' ', '_').replaceAll('.', ' ');
-
-			return new Endpoint(p,{id: id, address: this.address, bridgedDeviceBasicInformation: {
-
-				nodeLabel: this.label.rightWithToken(32,' '),
-                productName: this.productName.rightWithToken(32,' '),
-                productLabel: this.model.leftWithToken(64,' '),
-                serialNumber: id,
-                reachable: this.enabled,
-            }});
-
-
-
+			const id = this.address.replaceAll(' ', '_').replaceAll('.', ' ');
+			//@ts-ignore
+			return new Endpoint(p, {
+				id: id,
+				address: this.address,
+				bridgedDeviceBasicInformation: {
+					nodeLabel: this.label.rightWithToken(32, ' '),
+					productName: this.productName.rightWithToken(32, ' '),
+					productLabel: this.model.leftWithToken(64, ' '),
+					serialNumber: id,
+					reachable: this.enabled
+				}
+			});
 		}
 
 

package/src/Devices/ISYDevice.ts

@@ -1,10 +1,7 @@
 
-import { Commands, States } from '../ISYConstants.js';
-import { EndpointType, MutableEndpoint } from '@project-chip/matter.js/endpoint/type';
-import { Endpoint } from '@project-chip/matter.js/endpoint';
-import { BridgedDeviceBasicInformationServer } from '@project-chip/matter.js/behaviors/bridged-device-basic-information';
-import { SupportedBehaviors } from '@project-chip/matter.js/endpoint/properties';
 import { ClusterBehavior } from '@project-chip/matter.js/behavior/cluster';
+import type { Endpoint, EndpointType, MutableEndpoint } from '@project-chip/matter.js/endpoint';
+import type { SupportedBehaviors } from '@project-chip/matter.js/endpoint/properties';
 import 'winston'
 
 
@@ -100,7 +97,7 @@ export interface MapsToEndpointType<T extends EndpointType>  {
 type BehaviorList<T extends ClusterBehavior> = SupportedBehaviors & T;
 
 export interface MapsToEndpoint<T extends ClusterBehavior>
-{
+{//@ts-ignore
 	initialize<K extends MutableEndpoint.With<EndpointType.Empty,BehaviorList<T>>>(endpoint: Endpoint<K>): void;
 
 }

package/src/Devices/ISYDeviceNode.ts

@@ -1,6 +1,6 @@
 
 import type { Driver } from '../Definitions/Global/Drivers.js';
-import { type Family, type ISY, Controls } from '../ISY.js';
+import {type ISY } from '../ISY.js';
 import type { ISYDevice } from '../ISYDevice.js';
 import { ISYNode} from '../ISYNode.js';
 import type { ISYScene } from '../ISYScene.js';
@@ -10,7 +10,22 @@ import type { Category } from '../Definitions/Global/Categories.js';
 import type { Command } from '../Definitions/Global/Commands.js';
 import type { Event } from '../Definitions/Global/Events.js';
 import type { StringKeys } from '../Utils.js';
+import type { Family } from '../Definitions/index.js';
 
+export interface ISYDeviceInfo
+{
+	type: string;
+	deviceClass: any;
+
+	productName: string;
+
+	productId: string | number;
+
+	modelName: string;
+
+	modelNumber: string;
+
+}
 
 export class ISYDeviceNode<
   T extends Family,
@@ -18,7 +33,7 @@ export class ISYDeviceNode<
   C extends ISYNode.CommandSignatures,
   E extends ISYNode.EventSignatures = {[x in keyof D]: Event.DriverToEvent<D[x]> & {driver: x}} & {[x in keyof C]: Event.CommandToEvent<C[x]> & {command: x}}
 >
-  extends ISYNode<T, D, C, E>
+  extends ISYNode<T, D, C, E> implements ISYDeviceInfo
    {
   public declare family: T;
 
@@ -85,6 +100,8 @@ export class ISYDeviceNode<
     //   );
     // }
   }
+	productId: string | number;
+	modelName: string;
 
   _parentDevice: ISYDevice<T, any, any, any>;
   children: ISYNode<any, any, any, any>[];

package/src/Devices/ISYMultiNodeDevice.ts

@@ -1,7 +1,7 @@
 //import type { UnionToIntersection } from '@project-chip/matter-node.js/util.js';
 import type { Driver } from '../Definitions/Global/Drivers.js';
 import type { UnitOfMeasure } from '../Definitions/Global/UOM.js';
-import type { Family } from '../ISY.js';
+
 import type { ISYDevice } from '../ISYDevice.js';
 import type { DriverMap, ISYNode, NodeList } from '../ISYNode.js';
 import type { ISYScene } from '../ISYScene.js';