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

package/src/Matter/Bridge/Server.ts

@@ -1,6 +1,6 @@
-import { Endpoint, EndpointServer, Environment, ServerNode, StorageService, Time, VendorId } from '@matter/main';
+import { Endpoint, EndpointServer, Environment, MutableEndpoint, ServerNode, StorageService, Time, VendorId, type SupportedBehaviors } from '@matter/main';
 import { StorageBackendDisk } from '@project-chip/matter-node.js/storage';
-import { BridgedDeviceBasicInformationServer } from '@project-chip/matter.js/behaviors/bridged-device-basic-information';
+import { BridgedDeviceBasicInformationServer, type BridgedDeviceBasicInformationBehavior } from '@project-chip/matter.js/behaviors/bridged-device-basic-information';
 import { logEndpoint } from '@matter/main/protocol';
 import { DimmableLightDevice, OnOffLightDevice } from '@matter/main/devices';
 import { AggregatorEndpoint } from '@matter/main/endpoints/aggregator';
@@ -17,9 +17,14 @@ import { ISYBridgedDeviceBehavior } from '../Behaviors/ISYBridgedDeviceBehavior.
 import { ISYDimmableBehavior, ISYOnOffBehavior } from '../Behaviors/Insteon/ISYOnOffBehavior.js';
 import '../Mappings/Insteon.js';
 import type { ISYNode } from '../../ISYNode.js';
-import type { DeviceToClusterMap } from '../../Model/ClusterMap.js';
+import { MappingRegistry, type DeviceToClusterMap } from '../../Model/ClusterMap.js';
 import { Options } from '../../Definitions/ZWave/index.js';
 import { InsteonBaseDevice } from '../../Devices/Insteon/InsteonBaseDevice.js';
+import { DimmerLamp } from '../../Devices/Insteon/Generated/DimmerLamp.js';
+import { Family } from '../../Definitions/index.js';
+import { RelayLamp } from '../../Devices/Insteon/index.js';
+import type { DeviceTypeDefinition } from '@project-chip/matter.js/device';
+import type { BridgedISYNodeInformationServer } from '../../Devices/EndpointFor.js';
 
 
 // #region Interfaces (1)
@@ -70,6 +75,10 @@ export interface DeviceOptions {
 
 // #region Functions (3)
 
+let t : MutableEndpoint;
+
+
+
 export function create(isy?: ISY, config?: Config): Promise<ServerNode> {
 	return createMatterServer(isy, config);
 }
@@ -187,7 +196,7 @@ export async function createMatterServer(isy?: ISY, config?: Config): Promise<Se
 		}
 	});
 
-	logger.info(`Bridge Server Added`);
+	logger.info(`Bridge server added`);
 
 	/**
 	 * Matter Nodes are a composition of endpoints. Create and add a single multiple endpoint to the node to make it a
@@ -203,10 +212,12 @@ export async function createMatterServer(isy?: ISY, config?: Config): Promise<Se
 
 	await server.add(aggregator);
 
-	logger.info(`Bridge Aggregator Added`);
-
+	logger.info(`Bridge aggregator added`);
+	let endpoints = 0;
 	for (const node of isy.nodeMap.values()) {
 		let device = node as ISYDeviceNode<any, any, any>;
+		try
+		{
 		let deviceOptions = getDeviceOptions(node, config.DeviceOptions);
 		if(deviceOptions?.label)
 		{
@@ -220,16 +231,21 @@ export async function createMatterServer(isy?: ISY, config?: Config): Promise<Se
 			//const name = `OnOff ${isASocket ? "Socket" : "Light"} ${i}`;
 
 			//@ts-ignore
-			let baseBehavior: any; /*typeof (DimmableLightDevice.with(BridgedDeviceBasicInformationServer, ISYBridgedDeviceBehavior, ISYOnOffBehavior, ISYDimmableBehavior)) | typeof (OnOffLightDevice.with(BridgedDeviceBasicInformationServer, ISYBridgedDeviceBehavior, ISYOnOffBehavior));*/
+			//of (DimmableLightDevice.with(BridgedDeviceBasicInformationServer, ISYBridgedDeviceBehavior, ISYOnOffBehavior, ISYDimmableBehavior)) | typeof (OnOffLightDevice.with(BridgedDeviceBasicInformationServer, ISYBridgedDeviceBehavior, ISYOnOffBehavior));*/
+			let deviceType = MappingRegistry.getMapping(device)?.deviceType;
+
+
 
-			if (device instanceof Devices.Insteon.Dimmer || device instanceof Devices.Insteon.DimmerSwitch || device instanceof Devices.Insteon.KeypadDimmer) {
-				baseBehavior = DimmableLightDevice.with(BridgedDeviceBasicInformationServer, ISYBridgedDeviceBehavior, ISYOnOffBehavior, ISYDimmableBehavior);
+			let baseBehavior = deviceType;
+			if (DimmerLamp.isImplementedBy(device)) {
+
+				baseBehavior = deviceType?.with(ISYOnOffBehavior, ISYDimmableBehavior);
 				// if(device instanceof InsteonSwitchDevice)
 				// {
 				//     baseBehavior = DimmerSwitchDevice.with(BridgedDeviceBasicInformationServer);
-				// }
-			} else if (device instanceof Devices.Insteon.Relay || device instanceof Devices.Insteon.RelaySwitch) {
-				baseBehavior = OnOffLightDevice.with(BridgedDeviceBasicInformationServer, ISYBridgedDeviceBehavior, ISYOnOffBehavior);
+			}
+			else if (RelayLamp.isImplementedBy(device)) {
+				baseBehavior = deviceType?.with(ISYOnOffBehavior);
 				// if(device instanceof InsteonSwitchDevice)
 				// {
 				//     baseBehavior = OnOffLightSwitchDevice.with(BridgedDeviceBasicInformationServer);
@@ -237,6 +253,8 @@ export async function createMatterServer(isy?: ISY, config?: Config): Promise<Se
 			}
 
 			if (baseBehavior !== undefined) {
+
+				logger.info(`Device ${device.label} (${device.address}) with NodeDefId = ${device.nodeDefId} mapped to ${deviceType.name}`);
 				//@ts-ignore
 				const endpoint = new Endpoint(baseBehavior, {
 					id: serialNumber,
@@ -246,7 +264,7 @@ export async function createMatterServer(isy?: ISY, config?: Config): Promise<Se
 
 					bridgedDeviceBasicInformation: {
 						nodeLabel: device.label.rightWithToken(32),
-						vendorName: device instanceof InsteonBaseDevice ? InsteonBaseDevice.vendorName : isy.vendorName,
+						vendorName: device instanceof ISYDeviceNode ? device.manufacturer : isy.vendorName,
 						vendorId: VendorId(config.vendorId),
 						productName: device.productName.leftWithToken(32),
 						productLabel: device.model.leftWithToken(64),
@@ -263,10 +281,15 @@ export async function createMatterServer(isy?: ISY, config?: Config): Promise<Se
 				});
 
 				await aggregator.add(endpoint);
-				logger.info(`Endpoint Added ${JSON.stringify(endpoint.id)} for ${device.label} (${device.address})`);
+				logger.info(`Endpoint added ${JSON.stringify(endpoint.id)} for ${device.label} (${device.address})`);
+				endpoints++;
 				//endpoints.push({0:endpoint,1:device});
 			}
 			//endpoint.lifecycle.ready.on(()=> device.initialize(endpoint as any));
+		}}
+		catch(e)
+		{
+			logger.error(`Error adding endpoint for ${device.label} (${device.address}): ${e.message}`);
 		}
 
 		/**
@@ -275,8 +298,9 @@ export async function createMatterServer(isy?: ISY, config?: Config): Promise<Se
 		 * If the code in these change handlers fail then the change is also rolled back and not executed and an error is
 		 * reported back to the controller.
 		 */
-	}
 
+	}
+	logger.info(`${endpoints} endpoints added to bridge.`);
 	/**
 	 * In order to start the node and announce it into the network we use the run method which resolves when the node goes
 	 * offline again because we do not need anything more here. See the Full example for other starting options.

package/src/Matter/Mappings/Insteon.ts

@@ -1,46 +1,73 @@
 
-
-import { OnOffLightDevice } from '@project-chip/matter.js/devices/OnOffLightDevice';
 import { DriverType } from '../../Definitions/Global/Drivers.js';
 import { Family, type t } from '../../Definitions/Global/Families.js';
-import { Insteon } from '../../Devices/Insteon/index.js';
+import  * as Insteon from '../../Devices/Insteon/index.js';
 import { Devices } from '../../Devices/index.js';
 import { MappingRegistry, type DeviceToClusterMap, type EndpointMapping, type FamilyToClusterMap } from '../../Model/ClusterMap.js';
 
 //import InsteonMap from "./Insteon.json";
-import { DimmableLightDevice } from '@project-chip/matter.js/devices/DimmableLightDevice';
+
 import { Converter } from '../../Converters.js';
 import type { InsteonRelaySwitchDevice } from '../../Devices/Insteon/InsteonRelaySwitchDevice.js';
+import { DimmerSwitchDevice, GenericSwitchDevice, OnOffLightSwitchDevice, OnOffLightDevice, DimmableLightDevice } from '@matter/node/devices';
+import type { Identity } from '@matter/general';
+import { SwitchServer } from '@matter/node/behaviors';
+import type { Device } from '@project-chip/matter.js/device';
+import type { MutableEndpoint } from '@matter/node';
 
 const map: FamilyToClusterMap<Family.Insteon> = {
 	Family: Family.Insteon,
-	Relay: {
+
+	RelayLamp: {
 		deviceType: OnOffLightDevice,
 		mapping: {
 			OnOff: {
 				attributes: {
-					onOff: 'ST'
+					onOff: { driver: 'ST', converter: 'LevelFrom0To255.Boolean' }
 				},
 				commands: { on: 'DON' }
 			}
-		} as EndpointMapping<OnOffLightDevice, Insteon.Relay>
+
+		}
 	},
-	RelaySwitch: {
+	RelayLampSwitch: {
 		deviceType: OnOffLightDevice,
 		mapping: {
 			OnOff: {
 				attributes: {
-					onOff: 'ST'
+					onOff: { driver: 'ST', converter: 'LevelFrom0To255.Boolean' }
 				},
 				commands: { on: 'DON' }
 			}
 		}
+,},
+	DimmerLamp: {
+		deviceType: DimmableLightDevice,
+		// @ts-ignore
+		mapping: {
+			// @ts-ignore
+			OnOff: {
+				attributes: {
+					onOff: { driver: 'ST', converter: 'LevelFrom0To255.Boolean' }
+				},
+				commands: { on: 'DON' }
+			},
+			LevelControl: {
+				// @ts-ignore
+				attributes: {
+					currentLevel: { driver: 'ST', converter: 'LevelFrom0To255.LightingLevel' },
+					startUpCurrentLevel: { driver: 'OL', converter: 'LevelFrom0To255.LightingLevel' },
+					onLevel: { driver: 'OL', converter: 'LevelFrom0To255.LightingLevel' }
+				},
+				commands: { setLevel: { command: 'DON' } }
+			}
+		} as EndpointMapping<DimmableLightDevice, Insteon.DimmerLampNode>
 	},
-	Dimmer: {
-		
+	DimmerLampSwitch: {
 		deviceType: DimmableLightDevice,
 		// @ts-ignore
 		mapping: {
+
 			// @ts-ignore
 			OnOff: {
 				attributes: {
@@ -57,11 +84,9 @@ const map: FamilyToClusterMap<Family.Insteon> = {
 				},
 				commands: { setLevel: { command: 'DON' } }
 			}
-		} as EndpointMapping<DimmableLightDevice, Insteon.Dimmer>
+		} as EndpointMapping<DimmableLightDevice, Insteon.DimmerLampNode>
 	}
 };
 
-map.KeypadDimmer = map.Dimmer;
-map.DimmerSwitch = map.Dimmer;
 
 MappingRegistry.register(map);

package/src/Model/ClassDefinition.ts

@@ -72,12 +72,19 @@ function buildNodeClassDefinitions<T extends Family>(nodeDefs: NodeDef[], family
 					if (id.includes(id2)) {
 						node.implements.push(id2, ...node2.implements);
 						node.equivalentTo.push(id2);
+						node2.equivalents.push(id);
+
 					} else {
 						node2.implements.push(id, ...node.implements);
 						node2.equivalentTo.push(id);
+						node.equivalents.push(id2);
 					}
 				} else if (ext) {
 					node.implements.push(id2, ...node2.implements);
+					if(id.includes(id2))
+					{
+						node.extends.push(id2);
+					}
 				}
 
 				// if (Object.keys(d.).length == 0) {
@@ -113,10 +120,19 @@ function buildNodeClassDefinitions<T extends Family>(nodeDefs: NodeDef[], family
 					e = i;
 				}
 			}
-			node.extends = e;
+
 		}
 		map[node.id] = node;
 	}
+	for (const node of Object.values(map).filter((p) => p.implements.length > 0))
+	{
+		for (const i of node.implements)
+		{
+			let superNode = map[i];
+			if(superNode)
+				superNode.implementedBy?.push(node.id);
+		}
+	}
 	return map;
 }
 
@@ -127,11 +143,17 @@ export class NodeClassDefinition<T extends Family> {
 	public drivers: { [x in Driver.Type]?: DriverDefinition } = {};
 	public dynamic: boolean = false;
 	public equivalentTo: string[] = [];
+
+	public equivalents: string[] = [];
+
+
 	public events: { [x: string]: EventDefinition } = {};
-	public extends?: string;
+	public extends?: string[] = [];
 	public family: T;
 	public id: string;
 	public implements: string[] = [];
+
+	public implementedBy: string[] = [];
 	public label: string;
 	public nlsId: string;
 
@@ -262,7 +284,9 @@ export class NodeClassDefinition<T extends Family> {
 			dynamic: this.family in [Family.ZWave, Family.ZigBee],
 			implements: this.implements.length > 0 ? this.implements : undefined,
 			equivalentTo: this.equivalentTo.length > 0 ? this.equivalentTo : undefined,
-			extends: this.extends
+			extends: this.extends.length > 0 ? this.extends : undefined,
+			equivalents: this.equivalents.length > 0 ? this.equivalents : undefined,
+			implementedBy: this.implementedBy.length > 0 ? this.implementedBy : undefined
 		};
 	}
 
@@ -409,7 +433,7 @@ export abstract class NodeMemberDefinition<TId extends string> {
 			var d = {};
 			for (const rangeDef of toArray(e.range)) {
 				if ('subset' in rangeDef) {
-					d[rangeDef.uom] = { uom: rangeDef.uom, indexId: rangeDef.nls, ...this.#parseSubset(e) };
+					d[rangeDef.uom]= { uom: rangeDef.uom, indexId: rangeDef.nls, ...this.#parseSubset(e) };
 				} else {
 					d[rangeDef.uom] = {
 						uom: rangeDef.uom,
@@ -422,8 +446,14 @@ export abstract class NodeMemberDefinition<TId extends string> {
 						returnType: rangeDef.nls ? EnumDefinition.get(this.classDef.family, rangeDef.nls, rangeDef.uom, this.classDef.id)?.name : undefined
 					};
 				}
+				if(rangeDef.uom === UnitOfMeasure.Index)
+				{
+					d[rangeDef.uom].enum = true;
+				}
+
 			}
 			this.dataType = d;
+
 		}
 	}
 

package/src/Model/ClusterMap.ts

@@ -1,16 +1,20 @@
-import { ClusterBehavior } from '@project-chip/matter.js/behavior/cluster';
 import * as Clusters from '@project-chip/matter.js/cluster';
-import { OnOffLightDevice } from '@project-chip/matter.js/devices/OnOffLightDevice';
-import { SupportedBehaviors } from '@project-chip/matter.js/endpoint/properties';
-import type { MutableEndpoint } from '@project-chip/matter.js/endpoint/type';
+
 import type { Converter } from '../Converters.js';
 import { DriverType } from '../Definitions/Global/Drivers.js';
-import { Devices } from '../Devices/index.js';
-import { Insteon } from '../Devices/Insteon/index.js';
-
+import { Devices, Insteon } from '../Devices/index.js';
+
+import { ClusterBehavior, MutableEndpoint, SupportedBehaviors } from '@matter/main';
+import type { OnOffLightDevice } from '@matter/main/devices';
+import { BridgedDeviceBasicInformationBehavior } from '@matter/node/behaviors';
+import type { DeviceTypeDefinition } from '@project-chip/matter.js/device';
+import { Family } from '../Definitions/index.js';
+import { NodeFactory } from '../Devices/NodeFactory.js';
 import { CommandsOf, DriversOf, ISYNode } from '../ISYNode.js';
+import { ISYBridgedDeviceBehavior } from '../Matter/Behaviors/ISYBridgedDeviceBehavior.js';
+import { ISYOnOffBehavior } from '../Matter/Behaviors/Insteon/ISYOnOffBehavior.js';
+import type { PickOfType, Remove } from '../Utils.js';
 import { ClusterType } from './ClusterType.js';
-import type { Family } from '../Definitions/index.js';
 
 // #region Type aliases (16)
 
@@ -84,15 +88,12 @@ export type CommandMapping<B, D> =
 //     behavior?: typeof ClusterBehavior;
 
 // }
-export type DeviceToClusterMap<T extends ISYNode<Family, any, any, any>, D extends { behaviors: SupportedBehaviors; deviceType: string }> =
-	D extends { behaviors: SupportedBehaviors; deviceType: string } ?
-		{
-			deviceType: D;
-			mapping: EndpointMapping<D, T>;
-		}
-	:	never;
-export type EndpointMapping<A extends { behaviors: any }, D extends ISYNode<Family, any, any, any>> = {
-	[K in Capitalize<StringKeys<A['behaviors']>>]?: BehaviorMapping<A['behaviors'][Uncapitalize<K>], D>; //{
+export type DeviceToClusterMap<T extends ISYNode<Family, any, any, any>, D extends MutableEndpoint> = {
+	deviceType: D;
+	mapping: EndpointMapping<D, T>;
+};
+export type EndpointMapping<A extends MutableEndpoint, D extends ISYNode<Family, any, any, any>> = {
+	[K in StringKeys<PickOfType<A['behaviors'], ClusterBehavior>> as Capitalize<K>]?: A['behaviors'][K] extends ClusterBehavior ? BehaviorMapping<A['behaviors'][K], D> : undefined; //{
 	/*attributes?: AttributeMapping<A['behaviors'][Uncapitalize<K>], D>;
 		commands?: CommandMapping<A['behaviors'][Uncapitalize<K>], D>;*/
 	//};
@@ -115,8 +116,9 @@ export type EndpointMapping1<A extends MutableEndpoint, K> = {
 	attributes?: SBAttributeMapping<A['behaviors'], K>;
 	commands?: SBCommandMapping<A['behaviors'], K>;
 };
+//@ts-ignore
 export type FamilyToClusterMap<T extends Family.Insteon | Family.ZWave | Family.ZigBee> = { Family: T } & {
-	[Type in keyof Devices.Insteon]?: DeviceToClusterMap<InstanceType<Devices.Insteon[Type]>, any>;
+	[Type in Extract<keyof Devices.Insteon, `${string}Node`> as Remove<Type, 'Node'>]?: DeviceToClusterMap<InstanceType<Devices.Insteon[Type]>, MutableEndpoint>;
 };
 export type SBAttributeMapping<SB extends SupportedBehaviors, D> = {
 	[K in keyof SB]: Partial<Record<any, DriversOf<D> | { driver: DriversOf<D>; converter?: string }>>;
@@ -139,32 +141,43 @@ export type parameterMapping = {
 export class MappingRegistry {
 	// #region Properties (1)
 
-	public static map: Map<Family,Map<string, DeviceToClusterMap<any, any>>> = new Map();
+	public static map: Map<Family, Map<string, DeviceToClusterMap<ISYNode, MutableEndpoint>>> = new Map();
+
+	public static cache: { [x: string]: DeviceToClusterMap<ISYNode, MutableEndpoint> } = {};
 
 	// #endregion Properties (1)
 
 	// #region Public Static Methods (3)
 
-	public static getMapping<T extends ISYNode<any,any,any,any>>(device: ISYNode<any,any,any,any>) {
-		if(MappingRegistry.map.has(device.family))
-		{
-			let g = MappingRegistry.map.get(device.family);
-			if(g.has(device.constructor.name))
-			{
-				return g.get(device.constructor.name);
-			}
-			else if(g.has(device.nodeDefId))
-			{
-				return g.get(device.nodeDefId);
-			}
-			else if(g.has(device.type))
-			{
-				return g.get(device.type);
+	public static getMapping<T extends ISYNode<any, any, any, any>>(device: T): DeviceToClusterMap<T, MutableEndpoint> {
+		let m = this.cache[device.address];
+		if (!m) {
+			if (MappingRegistry.map.has(device.family)) {
+				let g = MappingRegistry.map.get(device.family);
+				//let m: DeviceToClusterMap<T,MutableEndpoint>;
+				if (g.has(device.constructor.name)) {
+					m = g.get(device.constructor.name);
+				} else if (g.has(device.nodeDefId)) {
+					m = g.get(device.nodeDefId);
+				} else if (g.has(device.type)) {
+					m = g.get(device.type);
+				}
+				if (!m) {
+					for (var nodeDefId of NodeFactory.getImplements(device)) {
+						if (g.has(nodeDefId)) {
+							device.logger(`Mapping found to ${Family[device.family]}.${nodeDefId}`, 'info');
+							m = g.get(nodeDefId);
+							g.set(device.nodeDefId, m);
+
+							break;
+						}
+					}
+				}
+				if (m !== null) this.cache[device.address] = m;
 			}
-
 		}
-		return null;
 
+		return m;
 	}
 
 	public static getMappingForBehavior<T extends ISYNode<any, any, any, any>, B extends ClusterBehavior>(device: T, behavior: B): BehaviorMapping<B, T> {
@@ -176,40 +189,43 @@ export class MappingRegistry {
 		}
 	}
 	//@ts-ignore
-	public static register(map: Partial<FamilyToClusterMap<any>> | {[x in Paths<typeof Devices>]: DeviceToClusterMap<any,any>}) {
-		if("Family" in map)
-		{
-			let regMap : Map<string, DeviceToClusterMap<any, any>>;
-			if(!MappingRegistry.map.has(map.Family))
-			{
+	public static register(map: Partial<FamilyToClusterMap<any>> | { [x in Paths<typeof Devices>]: DeviceToClusterMap<any, any> }) {
+		if ('Family' in map) {
+			let regMap: Map<string, DeviceToClusterMap<any, any>>;
+			if (!MappingRegistry.map.has(map.Family)) {
 				MappingRegistry.map.set(map.Family, new Map());
 			}
+
 			regMap = MappingRegistry.map.get(map.Family);
 			for (var key in map) {
 				if (key !== 'Family') {
-					regMap.set(key, map[key]);
-					regMap.set(Insteon[key]?.name, map[key]); //TODO: This is a hack to allow for the Insteon devices to be registered by name
+					let m = map[key] as DeviceToClusterMap<ISYNode, MutableEndpoint>;
+
+					m = { deviceType: m.deviceType.with(BridgedDeviceBasicInformationBehavior, ISYBridgedDeviceBehavior), mapping: m.mapping };
+					regMap.set(key, m);
+					regMap.set(Insteon[key]?.name, m);
+					regMap.set(Insteon[key].nodeDefId, m);
+
+					//TODO: This is a hack to allow for the Insteon devices to be registered by name
 				}
 			}
-		}
-		else
-		{
-			let regMap : Map<string, DeviceToClusterMap<any, any>>;
+		} else {
+			let regMap: Map<string, DeviceToClusterMap<any, any>>;
 			for (var key in map) {
-				const keys = key.split(".");
+				const keys = key.split('.');
 				let x = Devices[keys[0]][keys[1]] as typeof ISYNode<any, any, any, any>;
-				if(!MappingRegistry.map.has(x.family))
-				{
+				if (!MappingRegistry.map.has(x.family)) {
 					MappingRegistry.map.set(x.family, new Map());
 				}
-			//{family, key} = key.split(".")[0]
-
-			regMap = MappingRegistry.map.get(x.family);
+				//{family, key} = key.split(".")[0]
 
-			regMap.set(keys[1],map[key]);
-			regMap.set(x.name, map[key]);
+				regMap = MappingRegistry.map.get(x.family);
+				let m = map[key] as DeviceToClusterMap<ISYNode, MutableEndpoint>;
+				m = { deviceType: m.deviceType.with(BridgedDeviceBasicInformationBehavior, ISYBridgedDeviceBehavior), mapping: m.mapping };
 
-		}
+				regMap.set(keys[1], m);
+				regMap.set(x.name, m);
+			}
 		}
 	}
 

package/src/Model/NodeInfo.ts

@@ -131,7 +131,7 @@ export function family<F extends Family>(nodeInfo: NodeInfo<any>): nodeInfo is N
 }
 
 export function isDynamic(nodeInfo: NodeInfo<any>): nodeInfo is DynamicNodeInfo {
-	return nodeInfo.family in [Family.ZWave, Family.ZigBee];
+	return [Family.ZWave, Family.ZigBee].includes(nodeInfo.family);
 }
 
 export function isStatic(nodeInfo: NodeInfo<any>): nodeInfo is StaticNodeInfo {

package/src/Utils.ts

@@ -20,10 +20,48 @@ export type PickOfType<T, U> = { [K in keyof T]: T[K] extends U ? (any extends T
 
 export type Paths<T> = T extends object ? { [K in keyof T]: `${Exclude<K, symbol>}${'' | `.${Paths<T[K]>}`}` }[keyof T] : never;
 
+export type Prev = [never, 0,1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+
+
+export type RelaxTypes<V> =
+	V extends number ? number
+	: V extends bigint ? bigint
+	: V extends object ?
+		V extends (...args: any[]) => any ?
+			V
+		:	{
+				[K in keyof V]: RelaxTypes<V[K]>;
+			}
+	:	V;
+
+type p = Prev[10];
+export type Join<K, P> =
+	K extends string | number ?
+		P extends string | number ?
+			`${K}${'' extends P ? '' : '.'}${P}`
+		:	never
+	:	never;
+export type PathsWithLimit<T, D extends number = 10> =
+	[D] extends [never] ? never
+	: T extends object ? { [K in keyof T]-?: K extends string | number ? `${K}` | Join<K, PathsWithLimit<T[K], Prev[D]>> : never }[keyof T]
+	: '';
+
+export type Leaves<T, D extends number = 10> =
+	[D] extends [never] ? never
+	: T extends object ? { [K in keyof T]-?: Join<K, Leaves<T[K], Prev[D]>> }[keyof T]
+	: '';
+
 export function getEnumValueByEnumKey<E extends { [index: string]: number }, T extends keyof E>(enumType: E, enumKey: T): E[T] {
 	return enumType[enumKey];
 }
 
+export type Replace<K extends string, T extends string, U extends string> = K extends `${infer L}${T}${infer R}` ? `${L}${U}${R}` : K;
+
+export type Remove<K extends string, T extends string> = K extends `${infer L}${T}${infer R}` ? `${L}${R}` : K;
+
+export type ReplaceAll<K extends string, T extends string, U extends string> = K extends `${infer L}${T}${infer R}` ? `${L}${U}${ReplaceAll<R, T, U>}` : K;
+
+
 export function getEnumKeyByEnumValue<E extends { [index: string]: number }, T extends E[keyof E]>(enumType: E, enumValue: E[T]): T {
 	return Object.keys(enumType).find((key) => enumType[key] === enumValue) as unknown as T;
 }

package/tsconfig.json

@@ -27,6 +27,12 @@
 		"src/Definitions/Global/*.ts",
 	],
 	"exclude": [
-		"src/Devices/*/Generated/*",
+		
+		"src/Devices/ZigBeeLegacy/Generated/*",
+		"src/Devices/Poly/Generated/*",
+		"src/Devices/Brultech/Generated/*",
+
+		"src/Devices/NCD/Generated/*",
+		"src/Devices/Scene/Generated/*",
 	]
 }