isy-nodejs 1.0.7-alpha.0 → 1.0.8-alpha.0

package/src/Matter/Behaviors/BehaviorRegistry.ts

@@ -1,26 +1,62 @@
-import { ClusterBehavior, type Behavior } from '@matter/node';
-import type { RelaxTypes } from '../../Utils.js';
-import type { Constructor } from '../../Devices/Constructor.js';
+import { Behavior, type ClusterBehavior } from '@matter/node';
+import type { LabelsOf, RelaxTypes } from '../../Utils.js';
+
+import type { ISYNode } from '../../ISYNode.js';
+import { NodeFactory } from '../../Devices/NodeFactory.js';
+import { Registry } from '../../Registry.js';
+import type { Constructor } from 'type-fest';
+import type { ISYDeviceNode } from '../../Devices/ISYDeviceNode.js';
+import { Family } from '../../Definitions/Global/Families.js';
 
 
 
 export namespace BehaviorRegistry
 {
 
+	const registry = new Registry<string, Behavior.Type>();
+
+	export function register<T extends Behavior.Type, F extends Family, P extends ISYNode<F>>(behavior: T & {cluster: {name: string}, nodeClass: Constructor<P>}, family?: keyof typeof Family): void
+	{
+		if(family)
+		{
+			registry.register(behavior.cluster.name.toLowerCase(), behavior, family);
+			return;
+		}
+		registry.register(behavior.cluster.name.toLowerCase(), behavior, behavior.nodeClass as unknown as typeof ISYNode);
+	}
 
-	const registry: {[x:string]: Constructor<ClusterBehavior>} = {};
+	export function get<T extends ISYDeviceNode<any,any,any,any>>(node: T, cluster: string): Behavior.Type
+	{
+		return registry.get(node, cluster.toLowerCase());
+	}
 
-	type ClusterBehaviorType = RelaxTypes<Omit<typeof ClusterBehavior, "withInterface" | "unimplemented">>;
+	/*const registry: {[x:string]: Behavior.Type} = {};
+	const nodeLevelRegistry: {[x:string]: {[x:string]: Behavior.Type}} = {};
 
-	export function register<T extends Behavior.Type>(behavior: {cluster: {name: string}} & Constructor<ClusterBehavior>): void
+
+
+	register<T extends Behavior.Type>(behavior: T & {cluster: {name: string}, nodeClass: {nodeDefId}} ): void
 	{
 		registry[behavior.cluster.name.toLowerCase()] = behavior;
+		nodeLevelRegistry[behavior.nodeClass.nodeDefId] = nodeLevelRegistry[behavior.
+		nodeClass.nodeDefId] ?? {};
+		nodeLevelRegistry[behavior.nodeClass.nodeDefId][behavior.cluster.name.toLowerCase()] = behavior;
+
 	}
 
-	export function get(cluster: string): Constructor<ClusterBehavior>
+	 function get(nodeClass: typeof ISYNode, cluster: string): Behavior.Type
 	{
+		if(nodeLevelRegistry[nodeClass.nodeDefId])
+			return nodeLevelRegistry[nodeClass.nodeDefId][cluster.toLowerCase()];
+		else
+			for (const nodeDefId in NodeFactory.getImplements(nodeClass))
+			{
+				if(nodeLevelRegistry[nodeDefId][cluster.toLowerCase()])
+					return nodeLevelRegistry[nodeDefId][cluster.toLowerCase()];
+			}
 		return registry[cluster.toLowerCase()];
-	}
+
+	}*/
 
 
 }

package/src/Matter/Behaviors/ISYClusterBehavior.ts

@@ -8,6 +8,8 @@ import type { DriversOf, ISYNode } from '../../ISYNode.js';
 import type { ClusterMapping } from '../Mappings/MappingRegistry.js';
 import { ISYBridgedDeviceBehavior } from './ISYBridgedDeviceBehavior.js';
 import { isYieldExpression } from 'typescript';
+import { getConstructor, type ConstructorOf, type Factory } from '../../Utils.js';
+import { CompositeDevice } from '../../Devices/CompositeDevice.js';
 
 // #region Type aliases (6)
 
@@ -15,9 +17,10 @@ export type ClusterForBehavior<B> = B extends ClusterBehavior.Type<infer C, infe
 export type ConstructedType<B extends Constructor<any>> = B extends Constructor<infer C> ? C : never;
 // <reference path="MatterDevice.js" />
 // @ts-ignore
-export type DeviceBehavior<P extends ISYNode<any, any, any, any>, T extends { cluster? }> = {
+export interface DeviceBehavior<P extends ISYNode<any, any, any, any>, T extends { cluster? }> {
 	device: P;
 
+
 	bridgedDeviceBehavior: ISYBridgedDeviceBehavior<P>;
 
 	//ts-ignore
@@ -26,7 +29,7 @@ export type DeviceBehavior<P extends ISYNode<any, any, any, any>, T extends { cl
 	handlePropertyChange(chg: PropertyChange<P>): void;
 };
 type NotUnknown<T extends ClusterBehavior> = T extends { cluster: { name: 'Unknown' } } ? never : T;
-export type PropertyChange<P extends ISYNode<any, any, any, any>> = {
+export type PropertyChange<P extends ISYNode> = {
 	driver: keyof DriversOf<P>;
 	newValue: any;
 	oldValue: any;
@@ -38,13 +41,15 @@ type t = ClusterForBehavior<LevelControlBehavior>;
 
 // #region Functions (1)
 
-export function ISYClusterBehavior<T extends Constructor<ClusterBehavior> & { cluster }, P extends ISYNode<any, any, any, any>>(
+export function ISYClusterBehavior<T extends Constructor<ClusterBehavior> & { cluster }, P extends ISYNode<any, any, any, any>> (
 	base: T,
-	p: Constructor<P>
-): typeof base & { new (...args: any[]): DeviceBehavior<P, T> } {
-	return class ISYClusterBehavior extends base implements DeviceBehavior<P, T> {
+	p: Constructor<P> | Factory<P>
+): typeof base & { new (...args: any[]): DeviceBehavior<P, T> } & {nodeClass: Constructor<P>} {
+	let s = class ISYClusterBehavior extends base implements DeviceBehavior<P, T> {
 		_device: P;
 
+		static nodeClass = getConstructor(p);
+
 		handlers: { [x in keyof DriversOf<P>]: (newValue, oldValue, formattedValue) => void } = {} as any;
 
 		bridgedDeviceBehavior: ISYBridgedDeviceBehavior<P>;
@@ -101,6 +106,8 @@ export function ISYClusterBehavior<T extends Constructor<ClusterBehavior> & { cl
 			return (this._device = this._device ?? (this.agent.get(ISYBridgedDeviceBehavior).device as P));
 		}
 
+
+
 		async handlePropertyChange({ driver, newValue, oldValue, formattedValue }: PropertyChange<P>) {
 			// for (const key2 in this.map.attributes) {
 			//await this.initialize();
@@ -123,6 +130,8 @@ export function ISYClusterBehavior<T extends Constructor<ClusterBehavior> & { cl
 			// }
 		}
 	};
+	s.nodeClass = getConstructor(p);
+	return s;
 }
 
 // #endregion Functions (1)

package/src/Matter/Behaviors/Insteon/DimmerLevelControlBehavior.ts

@@ -0,0 +1,30 @@
+import type { MaybePromise } from '@matter/general';
+import { DimmableLightRequirements } from '@matter/node/devices';
+import { Converter } from '../../../Converters.js';
+import { IdEffect } from '../../../Definitions/ZigBee/index.js';
+import * as Insteon from '../../../Devices/Insteon/index.js';
+import { BehaviorRegistry } from '../BehaviorRegistry.js';
+import { ISYClusterBehavior } from '../ISYClusterBehavior.js';
+import { IdentifyBehavior } from './IdentifyBehavior.js';
+
+
+
+export class DimmerLevelControlBehavior extends ISYClusterBehavior(DimmableLightRequirements.LevelControlServer, Insteon.DimmerLamp) {
+	override async initialize(_options?: {}) {
+		await super.initialize(_options);
+		/*this.state.onLevel = Converter.get('Level255toZero.LightingLevel').to(this.device.drivers.OL)*/
+		//this.state.currentLevel = this.device.drivers.ST.value;
+		//this.state.onLevel = this.device.drivers.OL;
+	}
+
+	override setLevel(level: number): MaybePromise<void> {
+		level = Converter.Matter.LevelFrom0To255.LightingLevel.from(level);
+
+		if (level > 0) {
+			return this.device.on(level);
+		} else {
+			return this.device.off();
+		}
+	}
+}
+BehaviorRegistry.register(DimmerLevelControlBehavior);

package/src/Matter/Behaviors/Insteon/IdentifyBehavior.ts

@@ -0,0 +1,26 @@
+import { DimmableLightRequirements } from '@matter/node/devices';
+import { Identify } from '@project-chip/matter.js/cluster';
+import * as Insteon from '../../../Devices/Insteon/index.js';
+import { ISYClusterBehavior } from '../ISYClusterBehavior.js';
+import { BehaviorRegistry } from '../BehaviorRegistry.js';
+
+export class IdentifyBehavior extends ISYClusterBehavior(DimmableLightRequirements.IdentifyServer, Insteon.Relay) {
+	override async initialize(_options?: {}) {
+		await super.initialize(_options);
+	}
+
+	override async identify() {
+		return this.device.beep(100);
+	}
+
+	override async triggerEffect(request: Identify.TriggerEffectRequest) {
+		switch (request.effectIdentifier) {
+			case Identify.EffectIdentifier.Blink:
+				return this.device.on(100).then(() => this.device.off());
+			default:
+				return this.device.beep(100);
+		}
+	}
+}
+
+BehaviorRegistry.register(IdentifyBehavior);

package/src/Matter/Behaviors/Insteon/RelayOnOffBehavior.ts

@@ -0,0 +1,34 @@
+import { OnOffLightRequirements } from '@project-chip/matter.js/devices/OnOffLightDevice';
+import { InsteonRelayDevice } from '../../../Devices/Insteon/InsteonRelayDevice.js';
+
+import { ISYClusterBehavior, type PropertyChange } from '../ISYClusterBehavior.js';
+
+import { BehaviorRegistry } from '../BehaviorRegistry.js';
+import { Insteon } from '../../../Devices/index.js';
+
+export class RelayOnOffBehavior extends ISYClusterBehavior(OnOffLightRequirements.OnOffServer, Insteon.RelayLamp) {
+	override async initialize(_options?: {}) {
+		await super.initialize(_options);
+
+		//this.state.onOff = this.device.status;
+		//this.state.onOff = await this.device.state;
+	}
+
+	override on = async () => {
+		await this.device.on();
+
+		//this.device.commands.DON = true;
+	};
+
+	override async off() {
+		await this.device.off();
+
+		// this.device.drivers = false;
+	}
+
+	override async handlePropertyChange({ driver, newValue, oldValue, formattedValue }) {
+		return super.handlePropertyChange({ driver, newValue, oldValue, formattedValue });
+	}
+}
+
+BehaviorRegistry.register(RelayOnOffBehavior);

package/src/Matter/Behaviors/Insteon/index.ts

@@ -0,0 +1,3 @@
+export * from './DimmerLevelControlBehavior.js';
+export * from './IdentifyBehavior.js';
+export * from './RelayOnOffBehavior.js';

package/src/Matter/Bridge/Server.ts

@@ -1,20 +1,23 @@
 import { LogLevel, logLevelFromString, Logger as MatterLogger } from '@matter/general';
-import { Endpoint, EndpointServer, Environment, MutableEndpoint, ServerNode, StorageService, VendorId } from '@matter/main';
+import { ClusterBehavior, Endpoint, EndpointServer, Environment, MutableEndpoint, ServerNode, StorageService, VendorId } from '@matter/main';
 import { AggregatorEndpoint } from '@matter/main/endpoints/aggregator';
 import { logEndpoint } from '@matter/main/protocol';
+import { QrCode } from '@matter/main/types';
 import PackageJson from '@project-chip/matter.js/package.json' with { type: 'json' };
 import path from 'path';
 import { format, loggers } from 'winston';
+import { DimmerLamp, RelayLamp } from '../../Devices/Insteon/index.js';
 import { ISYDeviceNode } from '../../Devices/ISYDeviceNode.js';
 import { ISY } from '../../ISY.js';
 import type { ISYNode } from '../../ISYNode.js';
-import { ISYDimmableBehavior, ISYOnOffBehavior } from '../Behaviors/Insteon/ISYOnOffBehavior.js';
+
 import '../Mappings/index.js';
-import { RelayLamp, DimmerLamp } from '../../Devices/Insteon/index.js';
 import { MappingRegistry } from '../Mappings/MappingRegistry.js';
-import { QrCode } from '@matter/main/types';
-
-
+import { DimmerLevelControlBehavior } from '../Behaviors/Insteon/DimmerLevelControlBehavior.js';
+import { RelayOnOffBehavior } from '../Behaviors/Insteon/index.js';
+import { BehaviorRegistry } from '../Behaviors/BehaviorRegistry.js';
+import { isClusterServer } from '@project-chip/matter.js/cluster';
+import type { ISYDevice } from '../../ISYDevice.js';
 
 // #region Interfaces (1)
 
@@ -44,7 +47,7 @@ export interface Config {
 }
 
 export interface DeviceOptions {
-		applyTo:
+	applyTo:
 		| {
 				classes: (typeof ISYNode<any, any, any, any>)[];
 		  }
@@ -64,9 +67,7 @@ export interface DeviceOptions {
 
 // #region Functions (3)
 
-let t : MutableEndpoint;
-
-
+let t: MutableEndpoint;
 
 export function create(isy?: ISY, config?: Config): Promise<ServerNode> {
 	return createMatterServer(isy, config);
@@ -87,10 +88,8 @@ export function appliesTo(node: ISYNode<any>, deviceOptions: DeviceOptions): boo
 }
 
 export function getDeviceOptions(node: ISYNode<any>, deviceOptions: DeviceOptions[]): DeviceOptions['options'] {
-	if(deviceOptions)
-	{
-		if(Array.isArray(deviceOptions))
-		{
+	if (deviceOptions) {
+		if (Array.isArray(deviceOptions)) {
 			for (const options of deviceOptions) {
 				if (appliesTo(node, options)) {
 					return options.options; //TODO: rank by specificity
@@ -204,82 +203,93 @@ export async function createMatterServer(isy?: ISY, config?: Config): Promise<Se
 	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)
+		let device = node as ISYDeviceNode<any,any,any,any>
+		if(device.parentAddress !== device.address)
 		{
-			device.label = deviceOptions.label;
-		}
-		if (deviceOptions?.exclude) {
 			continue;
 		}
-		let uniqueId = `${device.address.replaceAll(' ', '_').replaceAll('.', '_')}`;
-		if (device.enabled) {
-			//const name = `OnOff ${isASocket ? "Socket" : "Light"} ${i}`;
-
-			//@ts-ignore
-			//of (DimmableLightDevice.with(BridgedDeviceBasicInformationServer, ISYBridgedDeviceBehavior, ISYOnOffBehavior, ISYDimmableBehavior)) | typeof (OnOffLightDevice.with(BridgedDeviceBasicInformationServer, ISYBridgedDeviceBehavior, ISYOnOffBehavior));*/
-			let deviceType = MappingRegistry.getMapping(device)?.deviceType;
+		try {
+			let deviceOptions = getDeviceOptions(node, config.DeviceOptions);
+			if (deviceOptions?.label) {
+				device.label = deviceOptions.label;
+			}
+			if (deviceOptions?.exclude) {
+				continue;
+			}
+			let uniqueId = `${device.address.replaceAll(' ', '_').replaceAll('.', '_')}`;
+			if (device.enabled) {
+				//const name = `OnOff ${isASocket ? "Socket" : "Light"} ${i}`;
 
+				//@ts-ignore
+				//of (DimmableLightDevice.with(BridgedDeviceBasicInformationServer, ISYBridgedDeviceBehavior, ISYOnOffBehavior, ISYDimmableBehavior)) | typeof (OnOffLightDevice.with(BridgedDeviceBasicInformationServer, ISYBridgedDeviceBehavior, ISYOnOffBehavior));*/
+				let deviceType = MappingRegistry.getMapping(device)?.deviceType;
 
 
-			let baseBehavior = deviceType;
-			if (DimmerLamp.isImplementedBy(device)) {
+				let baseBehavior = deviceType;
 
-				baseBehavior = deviceType?.with(ISYOnOffBehavior, ISYDimmableBehavior);
-				// if(device instanceof InsteonSwitchDevice)
-				// {
-				//     baseBehavior = DimmerSwitchDevice.with(BridgedDeviceBasicInformationServer);
-			}
-			else if (RelayLamp.isImplementedBy(device)) {
-				baseBehavior = deviceType?.with(ISYOnOffBehavior);
-				// if(device instanceof InsteonSwitchDevice)
-				// {
-				//     baseBehavior = OnOffLightSwitchDevice.with(BridgedDeviceBasicInformationServer);
-				// }
-			}
+				let b = deviceType?.behaviors;
 
-			if (baseBehavior !== undefined) {
+				for (let s in b)
+				{
+					let behavior = deviceType.behaviors[s] as ClusterBehavior.Type;
+					if(behavior.cluster && behavior.cluster.name !== 'Unknown')
+					{
+						let b = BehaviorRegistry.get(device,behavior.cluster.name);
+						if(b)
+						{
+							baseBehavior = deviceType.with(b);
+						}
+					}
+				}
 
-				logger.info(`Device ${device.label} (${device.address}) with NodeDefId = ${device.nodeDefId} mapped to ${deviceType.name}`);
-				//@ts-ignore
-				const endpoint = new Endpoint(baseBehavior, {
-					id: uniqueId,
-					isyNode: {
-						address: device.address
-					},
-
-					bridgedDeviceBasicInformation: {
-						nodeLabel: device.label.rightWithToken(32),
-						vendorName: device instanceof ISYDeviceNode ? device.manufacturer : 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),
-						softwareVersionString: `v.${device.version}`,
-
-						serialNumber: uniqueId,
-						reachable: true,
-						uniqueId: device.address
-
-					},
-
-				});
-
-				await aggregator.add(endpoint);
-				logger.info(`Endpoint added ${JSON.stringify(endpoint.id)} for ${device.label} (${device.address})`);
-				endpoints++;
-				//endpoints.push({0:endpoint,1:device});
+				/*if (DimmerLamp.isImplementedBy(device)) {
+					baseBehavior = deviceType?.with(RelayOnOffBehavior, DimmerLevelControlBehavior);
+					// if(device instanceof InsteonSwitchDevice)
+					// {
+					//     baseBehavior = DimmerSwitchDevice.with(BridgedDeviceBasicInformationServer);
+				} else if (RelayLamp.isImplementedBy(device)) {
+					baseBehavior = deviceType?.with(RelayOnOffBehavior);
+					// if(device instanceof InsteonSwitchDevice)
+					// {
+					//     baseBehavior = OnOffLightSwitchDevice.with(BridgedDeviceBasicInformationServer);
+					// }
+				}*/
+
+				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: uniqueId,
+						isyNode: {
+							address: device.address
+						},
+
+						bridgedDeviceBasicInformation: {
+							nodeLabel: device.label.rightWithToken(32),
+							vendorName: device instanceof ISYDeviceNode ? device.manufacturer : 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),
+							softwareVersionString: `v.${device.version}`,
+
+							serialNumber: uniqueId,
+							reachable: true,
+							uniqueId: device.address
+						}
+					});
+
+					await aggregator.add(endpoint);
+					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));
 			}
-			//endpoint.lifecycle.ready.on(()=> device.initialize(endpoint as any));
-		}}
-		catch(e)
-		{
+		} catch (e) {
 			logger.error(`Error adding endpoint for ${device.label} (${device.address}): ${e.message}`);
 		}
 
@@ -289,7 +299,6 @@ 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.`);
 	/**
@@ -366,15 +375,14 @@ async function initializeConfiguration(isy: ISY, config?: Config): Promise<Confi
 		environment.vars.set('discriminator', config.discriminator);
 	}
 
-	if(config.vendorId)	{
+	if (config.vendorId) {
 		environment.vars.set('vendorid', config.vendorId);
 	}
 
-	if(config.productId)	{
+	if (config.productId) {
 		environment.vars.set('productid', config.productId);
 	}
 
-
 	environment.vars.set('uniqueid', isy.id.replaceAll(':', '_'));
 
 	//logger.info(`Matter configuration: ${JSON.stringify(environment.vars)}`);
@@ -387,7 +395,7 @@ async function initializeConfiguration(isy: ISY, config?: Config): Promise<Confi
 	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(':', '_')));
+	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({

package/src/Matter/Mappings/Insteon.ts

@@ -55,13 +55,13 @@ export const map: FamilyToClusterMap<Family.Insteon> = {
 				},
 				commands: { setLevel: { command: 'DON' } }
 			}
-		} as EndpointMapping<DimmableLightDevice, Insteon.DimmerLampNode>
+		} as EndpointMapping<DimmableLightDevice, InstanceType<typeof Insteon.DimmerLamp.Node>>
 	},
 	DimmerLampSwitch: {
 		deviceType: DimmableLightDevice,
 		// @ts-ignore
 		mapping: {
-			
+
 			OnOff: {
 				attributes: {
 					onOff: { driver: 'ST', converter: 'Percent.Boolean' }
@@ -78,7 +78,7 @@ export const map: FamilyToClusterMap<Family.Insteon> = {
 				},
 				commands: { setLevel: { command: 'DON' } }
 			}
-		} as EndpointMapping<DimmableLightDevice, Insteon.DimmerLampNode>
+		} as EndpointMapping<DimmableLightDevice, InstanceType<typeof Insteon.DimmerLamp.Node>>
 	}
 };
 

package/src/Matter/Mappings/MappingRegistry.ts

@@ -1,22 +1,23 @@
+import * as Cluster from '@matter/types/cluster';
 import type * as Clusters from '@matter/types/clusters';
-import * as Cluster from '@matter/types/cluster'
 
-import type { Converter } from '../../Converters.js';
-import { DriverType } from '../../Definitions/Global/Drivers.js';
-import { Devices, Insteon } from '../../Devices/index.js';
-import type {Simplify, SimplifyDeep} from 'type-fest';
 import { ClusterBehavior, MutableEndpoint, SupportedBehaviors } from '@matter/main';
 import { DimmableLightDevice, OnOffLightDevice } from '@matter/main/devices';
 import { BridgedDeviceBasicInformationBehavior } from '@matter/node/behaviors';
 import type { DeviceTypeDefinition } from '@project-chip/matter.js/device';
+import type { Simplify, SimplifyDeep } from 'type-fest';
+import type { Converter } from '../../Converters.js';
+import { DriverType } from '../../Definitions/Global/Drivers.js';
 import { Family } from '../../Definitions/index.js';
 import type { Constructor } from '../../Devices/Constructor.js';
 import { NodeFactory } from '../../Devices/NodeFactory.js';
+import { Devices, Insteon } from '../../Devices/index.js';
 import { CommandsOf, DriversOf, ISYNode } from '../../ISYNode.js';
 import { ClusterType } from '../../Model/ClusterType.js';
 import type { PathsWithLimit, PickOfType, Remove } from '../../Utils.js';
 import { ISYBridgedDeviceBehavior } from '../Behaviors/ISYBridgedDeviceBehavior.js';
-import { ISYOnOffBehavior } from '../Behaviors/Insteon/ISYOnOffBehavior.js';
+import { BehaviorRegistry } from '../Behaviors/BehaviorRegistry.js';
+
 
 // #region Type aliases (16)
 
@@ -27,7 +28,6 @@ export type AttributeMapping<B, D> =
 export type ClusterMapping<B, T extends ISYNode<any, any, any, any>> = {
 	attributes?: ClusterAttributeMapping<B, T>;
 	commands?: ClusterCommandMapping<B, T>;
-
 };
 export type ClusterAttributeMapping<A, K> = {
 	[key in keyof Cluster.ClusterType.AttributesOf<A>]: { driver: Extract<keyof DriversOf<K>, string>; converter?: Converter.KnownConverters } | Extract<keyof DriversOf<K>, string>;
@@ -91,43 +91,33 @@ export type CommandMapping<B, D> =
 //     behavior?: typeof ClusterBehavior;
 
 // }
-export interface DeviceToClusterMap<T extends ISYNode<Family, any, any, any>, D extends MutableEndpoint>  {
+export interface DeviceToClusterMap<T extends ISYNode<Family, any, any, any>, D extends MutableEndpoint> {
 	deviceType: D;
 	mapping: EndpointMapping<D, T>;
-};
-
-
-
+}
 
 export interface Mapping<T extends ISYNode, D extends MutableEndpoint> {
 	deviceType: D;
 
 	nodeType?: T;
 	mapping?: {
-		[K in keyof D['behaviors']]?:
-		{attributes?: {
-			[K2 in keyof Cluster.ClusterType.AttributesOf<D['behaviors'][K]>]: { driver: keyof DriversOf<T>; converter?: Converter.KnownConverters } | keyof DriversOf<T>;
-		},
-		commands?: {
-			[K2 in keyof Cluster.ClusterType.CommandsOf<D['behaviors'][K]>]: { command: keyof CommandsOf<T>; converter?: Converter.KnownConverters } | keyof CommandsOf<T>;
-		}
-		}
-	}
-
-
-
+		[K in keyof D['behaviors']]?: {
+			attributes?: {
+				[K2 in keyof Cluster.ClusterType.AttributesOf<D['behaviors'][K]>]: { driver: keyof DriversOf<T>; converter?: Converter.KnownConverters } | keyof DriversOf<T>;
+			};
+			commands?: {
+				[K2 in keyof Cluster.ClusterType.CommandsOf<D['behaviors'][K]>]: { command: keyof CommandsOf<T>; converter?: Converter.KnownConverters } | keyof CommandsOf<T>;
+			};
+		};
+	};
 }
 
-   function addA<T extends ISYNode<any,any,any,any>,D extends MutableEndpoint>(mapping1: Mapping<T,D>, mapping2: Mapping<T,D>) : Mapping<T,D> {
-		return {deviceType: mapping1.deviceType, nodeType: mapping1.nodeType, mapping: {...mapping1.mapping, ...mapping2.mapping}};
-
-	}
-
-
-
+function addA<T extends ISYNode<any, any, any, any>, D extends MutableEndpoint>(mapping1: Mapping<T, D>, mapping2: Mapping<T, D>): Mapping<T, D> {
+	return { deviceType: mapping1.deviceType, nodeType: mapping1.nodeType, mapping: { ...mapping1.mapping, ...mapping2.mapping } };
+}
 
 export type EndpointMapping<A extends MutableEndpoint, D extends ISYNode<Family, any, any, any>> = {
-	[K in StringKeys<A['behaviors']>]?: ClusterMapping<A['behaviors'][K],D> //{
+	[K in StringKeys<A['behaviors']>]?: ClusterMapping<A['behaviors'][K], D>; //{
 	/*attributes?: AttributeMapping<A['behaviors'][Uncapitalize<K>], D>;
 		commands?: CommandMapping<A['behaviors'][Uncapitalize<K>], D>;*/
 	//};
@@ -154,13 +144,10 @@ export type EndpointMapping1<A extends MutableEndpoint, K> = {
 
 type SupportedFamily = Family.Insteon | Family.ZWave | Family.ZigBee;
 export type FamilyToClusterMap<T extends SupportedFamily> = { Family: T } & {
-	[Type in Extract<keyof Devices.Insteon, `${string}Node`> as Remove<Type, 'Node'>]?: DeviceToClusterMap<InstanceType<Devices.Insteon[Type]>, MutableEndpoint>;
+	[Type in keyof Devices.Insteon]?: Devices.Insteon[Type] extends {Node: Constructor<ISYNode<any,any,any,any>>} ?DeviceToClusterMap<InstanceType<Devices.Insteon[Type]["Node"]>, MutableEndpoint> : undefined;
 };
 
-interface ISYtoMatterMapping<N extends ISYNode, M extends MutableEndpoint> extends DeviceToClusterMap<N, M> {
-
-
-}
+interface ISYtoMatterMapping<N extends ISYNode, M extends MutableEndpoint> extends DeviceToClusterMap<N, M> {}
 
 export function add<const F extends SupportedFamily, const T extends ISYNode<F>, const D extends MutableEndpoint>(
 	familyToClusterMap: FamilyToClusterMap<F>,
@@ -275,7 +262,10 @@ export class MappingRegistry {
 
 				regMap = MappingRegistry.map.get(x.family);
 				let m = map[key] as DeviceToClusterMap<ISYNode, MutableEndpoint>;
-				m = { deviceType: m.deviceType.with(BridgedDeviceBasicInformationBehavior, ISYBridgedDeviceBehavior), mapping: m.mapping };
+				let deviceType = m.deviceType;
+				deviceType = deviceType.with(BridgedDeviceBasicInformationBehavior, ISYBridgedDeviceBehavior);
+
+				m = { deviceType: deviceType, mapping: m.mapping };
 
 				regMap.set(keys[1], m);
 				regMap.set(x.name, m);
@@ -299,8 +289,7 @@ var clusterMap = {
 	}
 };
 
-
-interface SimplyEndpointMapping<T extends ISYNode<Family, any, any, any>,K extends MutableEndpoint> extends SimplifyDeep<ISYtoMatterMapping<T,K>> {}
+interface SimplyEndpointMapping<T extends ISYNode<Family, any, any, any>, K extends MutableEndpoint> extends SimplifyDeep<ISYtoMatterMapping<T, K>> {}
 
 /*
 const map = {