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

package/src/Matter/Bridge/Server.ts

@@ -1,28 +1,33 @@
-import '@project-chip/matter-node.js';
-import { NodeJsEnvironment } from '@project-chip/matter-node.js/environment';
+import { Endpoint, EndpointServer, Environment, ServerNode, StorageService, Time, VendorId } from '@matter/main';
 import { StorageBackendDisk } from '@project-chip/matter-node.js/storage';
-import { CommissioningOptions } from '@project-chip/matter.js/behavior/system/commissioning';
 import { BridgedDeviceBasicInformationServer } from '@project-chip/matter.js/behaviors/bridged-device-basic-information';
-import { VendorId } from '@project-chip/matter.js/datatype';
-import { logEndpoint, OnOffBaseDevice } from '@project-chip/matter.js/device';
-import { Endpoint, EndpointServer } from '@project-chip/matter.js/endpoint';
-import { DimmableLightDevice, OnOffLightDevice } from '@project-chip/matter.js/endpoint/definitions';
-import type { SupportedBehaviors } from '@project-chip/matter.js/endpoint/properties';
-import { EndpointType, MutableEndpoint } from '@project-chip/matter.js/endpoint/type';
-import { AggregatorEndpoint } from '@project-chip/matter.js/endpoints/AggregatorEndpoint';
-import { StorageService } from '@project-chip/matter.js/environment';
-import { Level, levelFromString, Logger as MatterLogger } from '@project-chip/matter.js/log';
-import { ServerNode } from '@project-chip/matter.js/node';
+import { logEndpoint } from '@matter/main/protocol';
+import { DimmableLightDevice, OnOffLightDevice } from '@matter/main/devices';
+import { AggregatorEndpoint } from '@matter/main/endpoints/aggregator';
+import { LogLevel, logLevelFromString, Logger as MatterLogger, toHex } from '@matter/general';
+import { Devices } from '../../Devices/index.js';
+//@ts-ignore
+import PackageJson from '@project-chip/matter.js/package.json' with { type: 'json' };
 import { QrCode } from '@project-chip/matter.js/schema';
-import { resolve } from 'path';
-import { InsteonDimmableDevice, InsteonKeypadButtonDevice, InsteonRelayDevice, ISY } from '../../ISY.js';
+import path, { resolve } from 'path';
+import { format, loggers } from 'winston';
+import { ISYDeviceNode } from '../../Devices/ISYDeviceNode.js';
+import { ISY } from '../../ISY.js';
 import { ISYBridgedDeviceBehavior } from '../Behaviors/ISYBridgedDeviceBehavior.js';
-import { ISYDimmableBehavior, ISYOnOffBehavior } from '../Behaviors/ISYOnOffBehavior.js';
+import { ISYDimmableBehavior, ISYOnOffBehavior } from '../Behaviors/Insteon/ISYOnOffBehavior.js';
 import '../Mappings/Insteon.js';
-import type { ISYDeviceNode } from '../../Devices/ISYDeviceNode.js';
+import type { ISYNode } from '../../ISYNode.js';
+import type { DeviceToClusterMap } from '../../Model/ClusterMap.js';
+import { Options } from '../../Definitions/ZWave/index.js';
+import { InsteonBaseDevice } from '../../Devices/Insteon/InsteonBaseDevice.js';
+
 
 // #region Interfaces (1)
 
+export let instance: ServerNode;
+
+//@ts-ignore
+export let version: string = PackageJson.version;
 export interface Config {
 	// #region Properties (8)
 
@@ -35,9 +40,32 @@ export interface Config {
 	vendorId: number;
 	vendorName?: string;
 
+	ipv4?: boolean;
+
+	ipv6?: boolean;
+
+	DeviceOptions?: DeviceOptions[];
+
 	// #endregion Properties (8)
 }
 
+export interface DeviceOptions {
+	applyTo:
+		| {
+				classes: (typeof ISYNode<any, any, any, any>)[];
+		  }
+		| { nodeDefs: string[] }
+		| { addresses: string[] }
+		| { deviceTypes: string[] }
+		| { predicate: (node: ISYNode<any, any, any, any>) => boolean };
+	options: {
+		exclude?: boolean;
+		label: string;
+		//@ts-expect-error
+		mappings: { [x in typeof ISYNode<any, any, any, any> as x['name']]: DeviceToClusterMap<InstanceType<x>, any> };
+	};
+}
+
 // #endregion Interfaces (1)
 
 // #region Functions (3)
@@ -46,8 +74,46 @@ export function create(isy?: ISY, config?: Config): Promise<ServerNode> {
 	return createMatterServer(isy, config);
 }
 
+export function appliesTo(node: ISYNode<any>, deviceOptions: DeviceOptions): boolean {
+	if ('classes' in deviceOptions.applyTo) {
+		return deviceOptions.applyTo.classes?.some((x) => node instanceof x);
+	} else if ('nodeDefs' in deviceOptions.applyTo) {
+		return deviceOptions.applyTo.nodeDefs.includes(node.nodeDefId);
+	} else if ('addresses' in deviceOptions.applyTo) {
+		return deviceOptions.applyTo.addresses?.includes(node.address);
+	} else if ('deviceTypes' in deviceOptions.applyTo && node instanceof ISYDeviceNode) {
+		return deviceOptions.applyTo.deviceTypes?.includes(node.typeCode as string);
+	} else if ('predicate' in deviceOptions.applyTo) {
+		return deviceOptions.applyTo.predicate(node);
+	}
+}
+
+export function getDeviceOptions(node: ISYNode<any>, deviceOptions: DeviceOptions[]): DeviceOptions['options'] {
+	if(deviceOptions)
+	{
+		if(Array.isArray(deviceOptions))
+		{
+			for (const options of deviceOptions) {
+				if (appliesTo(node, options)) {
+					return options.options; //TODO: rank by specificity
+				}
+			}
+		}
+		for (const options of deviceOptions) {
+			if (appliesTo(node, options)) {
+				return options.options; //TODO: rank by specificity
+			}
+		}
+	}
+	return undefined;
+}
+
 export async function createMatterServer(isy?: ISY, config?: Config): Promise<ServerNode> {
-	var logger = isy.logger;
+	var logger = loggers.add('matter', {
+		transports: isy.logger.transports,
+		levels: isy.logger.levels,
+		format: format.label({ label: 'Matter' })
+	});
 	if (isy === undefined) {
 		isy = ISY.instance;
 	}
@@ -55,21 +121,29 @@ export async function createMatterServer(isy?: ISY, config?: Config): Promise<Se
 	try {
 		MatterLogger.addLogger(
 			'polyLogger',
-			(level, message) => logger.log(Level[level].toLowerCase().replace('notice', 'info'), message.slice(23).remove(Level[level]).trimStart()) /*Preserve existing formatting, but trim off date*/,
+			(lvl, message) => {
+				let msg = message.slice(23).remove(LogLevel[lvl]).trimStart();
+				let level = LogLevel[lvl].toLowerCase().replace('notice', 'info');
+				if (msg.startsWith('EndpointStructureLogger')) {
+					if (lvl === LogLevel.INFO) level = 'debug';
+				}
+				logger.log(level, msg);
+			},
+			/*Preserve existing formatting, but trim off date*/
 			{
-				defaultLogLevel: levelFromString(logger.level),
+				defaultLogLevel: logLevelFromString(logger.level),
 				logFormat: 'plain'
 			}
 		);
 	} finally {
-		MatterLogger.defaultLogLevel = levelFromString(logger.level);
+		MatterLogger.defaultLogLevel = logLevelFromString(logger.level);
 	}
 
 	config = await initializeConfiguration(isy, config);
 
-	logger.info(`Matter config read: ${JSON.stringify(config)}`);
-
-	const server = await ServerNode.create({
+	logger.info(`Matter config: ${JSON.stringify(config)}`);
+	MatterLogger.removeLogger('default'); /*Remove existing logging*/
+	let server = await ServerNode.create({
 		// Required: Give the Node a unique ID which is used to store the state of this node
 		id: config.uniqueId,
 
@@ -78,7 +152,7 @@ export async function createMatterServer(isy?: ISY, config?: Config): Promise<Se
 		network: {
 			port: config.port,
 
-			//ipv4: false,
+			ipv4: config.ipv4,
 			discoveryCapabilities: {
 				onIpNetwork: true
 			}
@@ -107,6 +181,7 @@ export async function createMatterServer(isy?: ISY, config?: Config): Promise<Se
 			productName: config.productName,
 			productLabel: config.productName,
 			productId: config.productId,
+			softwareVersionString: isy.firmwareVersion,
 			serialNumber: isy.id,
 			uniqueId: config.uniqueId
 		}
@@ -130,24 +205,30 @@ export async function createMatterServer(isy?: ISY, config?: Config): Promise<Se
 
 	logger.info(`Bridge Aggregator Added`);
 
-	const endpoints: { 0: Endpoint; 1: InsteonRelayDevice }[] = [];
-
 	for (const node of isy.nodeMap.values()) {
 		let device = node as ISYDeviceNode<any, any, any>;
+		let deviceOptions = getDeviceOptions(node, config.DeviceOptions);
+		if(deviceOptions?.label)
+		{
+			device.label = deviceOptions.label;
+		}
+		if (deviceOptions?.exclude) {
+			continue;
+		}
 		let serialNumber = `${device.address.replaceAll(' ', '_').replaceAll('.', '_')}`;
-		if (device.enabled && !(device instanceof InsteonKeypadButtonDevice)) {
+		if (device.enabled) {
 			//const name = `OnOff ${isASocket ? "Socket" : "Light"} ${i}`;
 
 			//@ts-ignore
-			let baseBehavior: MutableEndpoint.With<DimmableLightDevice | OnOffLightDevice, SupportedBehaviors.MapOf<[typeof BridgedDeviceBasicInformationServer, typeof ISYBridgedDeviceBehavior]>>;
+			let baseBehavior: any; /*typeof (DimmableLightDevice.with(BridgedDeviceBasicInformationServer, ISYBridgedDeviceBehavior, ISYOnOffBehavior, ISYDimmableBehavior)) | typeof (OnOffLightDevice.with(BridgedDeviceBasicInformationServer, ISYBridgedDeviceBehavior, ISYOnOffBehavior));*/
 
-			if (device instanceof InsteonDimmableDevice) {
+			if (device instanceof Devices.Insteon.Dimmer || device instanceof Devices.Insteon.DimmerSwitch || device instanceof Devices.Insteon.KeypadDimmer) {
 				baseBehavior = DimmableLightDevice.with(BridgedDeviceBasicInformationServer, ISYBridgedDeviceBehavior, ISYOnOffBehavior, ISYDimmableBehavior);
 				// if(device instanceof InsteonSwitchDevice)
 				// {
 				//     baseBehavior = DimmerSwitchDevice.with(BridgedDeviceBasicInformationServer);
 				// }
-			} else if (device instanceof InsteonRelayDevice) {
+			} else if (device instanceof Devices.Insteon.Relay || device instanceof Devices.Insteon.RelaySwitch) {
 				baseBehavior = OnOffLightDevice.with(BridgedDeviceBasicInformationServer, ISYBridgedDeviceBehavior, ISYOnOffBehavior);
 				// if(device instanceof InsteonSwitchDevice)
 				// {
@@ -165,10 +246,11 @@ export async function createMatterServer(isy?: ISY, config?: Config): Promise<Se
 
 					bridgedDeviceBasicInformation: {
 						nodeLabel: device.label.rightWithToken(32),
-						vendorName: 'Insteon Technologies, Inc.',
+						vendorName: device instanceof InsteonBaseDevice ? InsteonBaseDevice.vendorName : isy.vendorName,
 						vendorId: VendorId(config.vendorId),
 						productName: device.productName.leftWithToken(32),
 						productLabel: device.model.leftWithToken(64),
+
 						hardwareVersion: Number(device.version),
 						hardwareVersionString: `v.${device.version}`,
 						softwareVersion: Number(device.version),
@@ -200,10 +282,6 @@ export async function createMatterServer(isy?: ISY, config?: Config): Promise<Se
 	 * offline again because we do not need anything more here. See the Full example for other starting options.
 	 * The QR Code is printed automatically.
 	 */
-	process.on('SIGINT', async () => {
-		logger.info('Bringing server offline');
-		server.close();
-	});
 
 	logger.info('Bringing server online');
 	await server.start();
@@ -220,50 +298,81 @@ export async function createMatterServer(isy?: ISY, config?: Config): Promise<Se
 	// logEndpoint(EndpointServer.forEndpoint(server), {logAttributePrimitiveValues: true, logAttributeObjectValues: true});
 	//else if(logger.isDebugEnabled())
 	// {
-	logEndpoint(EndpointServer.forEndpoint(server), { logAttributePrimitiveValues: true, logAttributeObjectValues: false });
+	logEndpoint(EndpointServer.forEndpoint(server), { logAttributePrimitiveValues: true, logAttributeObjectValues: false, logClusterGlobalAttributes: false });
 	// }
 	if (server.lifecycle.isOnline) {
 		const { qrPairingCode, manualPairingCode } = server.state.commissioning.pairingCodes;
 
-		logger.info(QrCode.get(qrPairingCode));
+		logger.info('\n' + QrCode.get(qrPairingCode));
 		logger.info(`QR Code URL: https://project-chip.github.io/connectedhomeip/qrcode.html?data=${qrPairingCode}`);
 		logger.info(`Manual pairing code: ${manualPairingCode}`);
 	}
-	/*for(let e of endpoints)
-	{
-	  e[1].initialize(e[0] as any);
-	}*/
-
+	instance = server;
 	return server;
 }
 
+type PairingCodeData = {
+	qrPairingCode: string;
+	manualPairingCode: string;
+	renderedQrPairingCode: string;
+	url: string | URL;
+};
+
+export function getPairingCode(server: ServerNode = instance): PairingCodeData {
+	let codes = server.state.commissioning.pairingCodes as PairingCodeData;
+	codes.renderedQrPairingCode = QrCode.get(codes.qrPairingCode);
+	codes.url = `https://project-chip.github.io/connectedhomeip/qrcode.html?data=${codes.qrPairingCode}`;
+	return codes;
+}
+
 async function initializeConfiguration(isy: ISY, config?: Config): Promise<Config> {
 	var logger = isy.logger;
 
-	const environment = NodeJsEnvironment();
-
+	const environment = Environment.default;
 	const storageService = environment.get(StorageService);
-	environment.vars.set('storage.path', `${ISY.instance.storagePath}matter`);
+	const storagePath = path.resolve(isy.storagePath, 'matter');
+
+	environment.vars.set('storage.path', storagePath);
+
 	environment.vars.use(() => {
-		const location = environment.vars.get('storage.path', environment.vars.get('path.root', '.'));
-		storageService.location = location;
+		storageService.location = storagePath;
 	});
-	storageService.factory = (namespace) => new StorageBackendDisk(resolve(storageService.location ?? '.', namespace), environment.vars.get('storage.clear', false));
+
+	storageService.factory = (namespace) => new StorageBackendDisk(path.resolve(storageService.location ?? '.', namespace), environment.vars.get('storage.clear', false));
 	logger.info(`Matter storage location: ${storageService.location} (Directory)`);
 
-	const deviceStorage = (await storageService.open('device')).createContext('data');
+	const deviceStorage = (await storageService.open('bridge')).createContext('data');
+
+	if (config.passcode) {
+		environment.vars.set('passcode', config.passcode);
+	}
+
+	if (config.discriminator) {
+		environment.vars.set('discriminator', config.discriminator);
+	}
+
+	if(config.vendorId)	{
+		environment.vars.set('vendorid', config.vendorId);
+	}
+
+	if(config.productId)	{
+		environment.vars.set('productid', config.productId);
+	}
+
+	if(config.uniqueId)	{
+		environment.vars.set('uniqueid', config.uniqueId);
+	}
+
 
 	const vendorName = isy.vendorName;
-	const passcode = config.passcode ?? environment.vars.number('passcode') ?? (await deviceStorage.get('passcode', 20202021));
-	const discriminator = config.discriminator ?? environment.vars.number('discriminator') ?? (await deviceStorage.get('discriminator', 3840));
+	const passcode = environment.vars.number('passcode') ?? (await deviceStorage.get('passcode', 20202021));
+	const discriminator = environment.vars.number('discriminator') ?? (await deviceStorage.get('discriminator', 3840));
 	// product name / id and vendor id should match what is in the device certificate
-	const vendorId = config.vendorId ?? environment.vars.number('vendorid') ?? (await deviceStorage.get('vendorid', 0xfff1));
-	const productId = config.productId ?? environment.vars.number('productid') ?? (await deviceStorage.get('productid', 0x8000));
-	const productName = isy.productName;
-	const port = config.port ?? environment.vars.number('port') ?? 5540;
-
-	const uniqueId = isy.id.replaceAll(':', '_');
-	//environment.vars.string("uniqueid") ?? (await deviceStorage.get("uniqueid", Time.nowMs().toString()));
+	const vendorId = environment.vars.number('vendorid') ?? (await deviceStorage.get('vendorid', 0xfff1));
+	const productId = environment.vars.number('productid') ?? (await deviceStorage.get('productid', isy.productId));
+	const productName = environment.vars.string('productname') ?? (await deviceStorage.get('productname', isy.productName));
+	const port = environment.vars.number('port') ?? 5540;
+	const uniqueId = environment.vars.string("uniqueid") ?? (await deviceStorage.get("uniqueid", isy.id.replaceAll(':', '_')));
 
 	// Persist basic data to keep them also on restart
 	await deviceStorage.set({
@@ -271,6 +380,7 @@ async function initializeConfiguration(isy: ISY, config?: Config): Promise<Confi
 		discriminator,
 		vendorid: vendorId,
 		productid: productId,
+		productName: productName,
 		uniqueid: uniqueId
 	});
 
@@ -283,7 +393,9 @@ async function initializeConfiguration(isy: ISY, config?: Config): Promise<Confi
 		productName,
 		productId,
 		port,
-		uniqueId
+		uniqueId,
+		ipv4: config.ipv4 ?? true,
+		ipv6: config.ipv6 ?? true
 	};
 }
 

package/src/Matter/Mappings/Insteon.ts

@@ -1,5 +1,5 @@
-import { OnOffCluster } from '@project-chip/matter.js/cluster';
-import { DeviceTypeDefinition, DeviceTypes, OnOffBaseDevice } from '@project-chip/matter.js/device';
+
+
 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';
@@ -19,7 +19,7 @@ const map: FamilyToClusterMap<Family.Insteon> = {
 		mapping: {
 			OnOff: {
 				attributes: {
-					onOff: { driver: 'ST', converter: 'Percent.Boolean' }
+					onOff: 'ST'
 				},
 				commands: { on: 'DON' }
 			}
@@ -37,8 +37,11 @@ const map: FamilyToClusterMap<Family.Insteon> = {
 		}
 	},
 	Dimmer: {
+		
 		deviceType: DimmableLightDevice,
+		// @ts-ignore
 		mapping: {
+			// @ts-ignore
 			OnOff: {
 				attributes: {
 					onOff: { driver: 'ST', converter: 'LevelFrom0To255.Boolean' }
@@ -46,12 +49,15 @@ const map: FamilyToClusterMap<Family.Insteon> = {
 				commands: { on: 'DON' }
 			},
 			LevelControl: {
+				// @ts-ignore
 				attributes: {
-					currentLevel: { driver: DriverType.Status, converter: 'LevelFrom0To255.LightingLevel' }
+					currentLevel: { driver: 'ST', converter: 'LevelFrom0To255.LightingLevel' },
+					startUpCurrentLevel: { driver: 'OL', converter: 'LevelFrom0To255.LightingLevel' },
+					onLevel: { driver: 'OL', converter: 'LevelFrom0To255.LightingLevel' }
 				},
-				commands: { moveToLevel: { command: 'DON' } }
+				commands: { setLevel: { command: 'DON' } }
 			}
-		}
+		} as EndpointMapping<DimmableLightDevice, Insteon.Dimmer>
 	}
 };
 

package/src/Model/ClassDefinition.ts

@@ -1,4 +1,4 @@
-import { camelize, capitalize } from '@project-chip/matter.js/util';
+import { camelize, capitalize } from '@matter/general';
 import camelcase from 'camelcase';
 import { getRandomValues } from 'crypto';
 //import { detailedDiff } from 'deep-object-diff';

package/src/Model/ClusterMap.ts

@@ -1,23 +1,16 @@
-import { Behavior } from '@project-chip/matter.js/behavior';
 import { ClusterBehavior } from '@project-chip/matter.js/behavior/cluster';
-import type { OnOffBehavior } from '@project-chip/matter.js/behaviors/on-off';
 import * as Clusters from '@project-chip/matter.js/cluster';
-import { type Device, type DeviceTypeDefinition, type OnOffBaseDevice } from '@project-chip/matter.js/device';
 import { OnOffLightDevice } from '@project-chip/matter.js/devices/OnOffLightDevice';
-import * as DeviceTypes from '@project-chip/matter.js/endpoint/definitions';
 import { SupportedBehaviors } from '@project-chip/matter.js/endpoint/properties';
 import type { MutableEndpoint } from '@project-chip/matter.js/endpoint/type';
-import type { Identity } from '@project-chip/matter.js/util';
-import test from 'node:test';
 import type { Converter } from '../Converters.js';
-import { Driver, DriverType } from '../Definitions/Global/Drivers.js';
-import { Devices, type ToDevice } from '../Devices/index.js';
+import { DriverType } from '../Definitions/Global/Drivers.js';
+import { Devices } from '../Devices/index.js';
 import { Insteon } from '../Devices/Insteon/index.js';
-import { Family, InsteonRelayDevice } from '../ISY.js';
-import type { ISYDevice } from '../ISYDevice.js';
-import type { CommandsOf, DriversOf, ISYNode } from '../ISYNode.js';
-import type { ClusterForBehavior } from '../Matter/Behaviors/ISYClusterBehavior.js';
+
+import { CommandsOf, DriversOf, ISYNode } from '../ISYNode.js';
 import { ClusterType } from './ClusterType.js';
+import type { Family } from '../Definitions/index.js';
 
 // #region Type aliases (16)
 
@@ -126,7 +119,7 @@ export type FamilyToClusterMap<T extends Family.Insteon | Family.ZWave | Family.
 	[Type in keyof Devices.Insteon]?: DeviceToClusterMap<InstanceType<Devices.Insteon[Type]>, any>;
 };
 export type SBAttributeMapping<SB extends SupportedBehaviors, D> = {
-	[K in keyof SB]: Partial<Record<keyof Behavior.StateOf<SB[K]>, DriversOf<D> | { driver: DriversOf<D>; converter?: string }>>;
+	[K in keyof SB]: Partial<Record<any, DriversOf<D> | { driver: DriversOf<D>; converter?: string }>>;
 };
 export type SBCommandMapping<SB extends SupportedBehaviors, D> = {
 	//@ts-expect-error
@@ -146,14 +139,32 @@ export type parameterMapping = {
 export class MappingRegistry {
 	// #region Properties (1)
 
-	public static map: Map<string, DeviceToClusterMap<any, any>> = new Map();
+	public static map: Map<Family,Map<string, DeviceToClusterMap<any, any>>> = new Map();
 
 	// #endregion Properties (1)
 
 	// #region Public Static Methods (3)
 
-	public static getMapping<T extends ISYNode<any, any, any, any>>(device: T) {
-		return MappingRegistry.map.get(device.constructor.name);
+	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);
+			}
+
+		}
+		return null;
+
 	}
 
 	public static getMappingForBehavior<T extends ISYNode<any, any, any, any>, B extends ClusterBehavior>(device: T, behavior: B): BehaviorMapping<B, T> {
@@ -164,14 +175,42 @@ export class MappingRegistry {
 			if (behavior.cluster.name === m) return MappingRegistry.getMapping(device).mapping[m] as unknown as BehaviorMapping<B, T>;
 		}
 	}
-
-	public static register(map: Partial<FamilyToClusterMap<any>>) {
-		for (var key in map) {
-			if (key !== 'Family') {
-				MappingRegistry.map.set(key, map[key]);
-				MappingRegistry.map.set(Insteon[key].name, map[key]);
+	//@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))
+			{
+				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
+				}
 			}
 		}
+		else
+		{
+			let regMap : Map<string, DeviceToClusterMap<any, any>>;
+			for (var key in map) {
+				const keys = key.split(".");
+				let x = Devices[keys[0]][keys[1]] as typeof ISYNode<any, any, any, any>;
+				if(!MappingRegistry.map.has(x.family))
+				{
+					MappingRegistry.map.set(x.family, new Map());
+				}
+			//{family, key} = key.split(".")[0]
+
+			regMap = MappingRegistry.map.get(x.family);
+
+			regMap.set(keys[1],map[key]);
+			regMap.set(x.name, map[key]);
+
+		}
+		}
 	}
 
 	// #endregion Public Static Methods (3)
@@ -189,7 +228,7 @@ var clusterMap = {
 		moveToColor: { command: DriverType.CustomControl1, parameters: { colorX: { parameter: 'colorX' }, colorY: { parameter: 'colorY' }, colorTemperature: { parameter: 'colorTemperature' } } }
 	}
 };
-const map: EndpointMapping<OnOffLightDevice, InsteonRelayDevice> = {
+/*const map: EndpointMapping<OnOffLightDevice, InsteonRelayDevice> = {
 	Identify: {},
 	OnOff: {
 		attributes: {
@@ -199,6 +238,6 @@ const map: EndpointMapping<OnOffLightDevice, InsteonRelayDevice> = {
 			onWithTimedOff: { command: 'DON' }
 		}
 	}
-};
+};*/
 
 // #endregion Variables (3)

package/src/Model/NodeDef.ts

@@ -1,8 +1,7 @@
 import { isArray } from 'util';
 import { Driver } from '../Definitions/Global/Drivers.js'
 import type { MaybeArray } from '../Utils.js';
-import type { Identity } from '@project-chip/matter.js/util';
-import { ObjectSchema } from '@project-chip/matter.js/tlv';
+
 
 export interface DriverDef {
     id: Driver.Type;

package/src/Model/NodeInfo.ts

@@ -1,10 +1,11 @@
-import { NodeClassRegistry } from '../Devices/NodeFactory.js';
-import { Family } from '../ISY.js';
+import { Family } from '../Definitions/index.js';
+
+
 import type { DriverState } from './DriverState.js';
 
 // #region Type aliases (1)
 
-export type NodeInfo<T extends Family = Family> = T extends Family.ZWave ? DynamicNodeInfo : StaticNodeInfo;
+export type NodeInfo<T extends Family = Family> = (T extends Family.ZWave | Family.ZigBee ? DynamicNodeInfo : StaticNodeInfo) & { state?: { [x: string]: DriverState } };
 
 // #endregion Type aliases (1)
 
@@ -47,6 +48,7 @@ export interface DynamicNodeInfo {
 	parent?: Parent;
 	pnode: any;
 	property?: DriverState[] | DriverState;
+
 	rpnode: string;
 	sgid: string;
 	startDelay: number;