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

package/src/ISYDevice.ts

@@ -1,67 +1,78 @@
 import type { Command } from './Definitions/Global/Commands.js';
 import type { Driver } from './Definitions/Global/Drivers.js';
 import type { UnitOfMeasure } from './Definitions/Global/UOM.js';
-import type { Family } from './Definitions/index.js';
+import type { Category, Family } from './Definitions/index.js';
+import { ISYDeviceNode } from './Devices/ISYDeviceNode.js';
 import type { ISY } from './ISY.js';
 import type { ISYNode } from './ISYNode.js';
 import type { ISYScene } from './ISYScene.js';
 import type { DriverState } from './Model/DriverState.js';
 import type { StringKeys } from './Utils.js';
 
-export interface ISYDevice<T extends Family, D extends ISYNode.DriverSignatures, C extends ISYNode.CommandSignatures, E extends string = string> {
-  // #region Properties (22)
-
-  _parentDevice: ISYDevice<T, any, any, any>;
-  address: string;
-  category: number;
-  children: Array<ISYNode<any, any, any, any>>;
-  commands: Command.ForAll<C>;
-  deviceClass: any;
-  drivers: Driver.ForAll<D>;
-  enabled: boolean;
-  family: T;
-  hidden: boolean;
-  isDimmable: boolean;
-  label: string;
-  model: string;
-  modelNumber: string;
-  name: any;
-  parentAddress: any;
-  productName: string;
-  scenes: ISYScene[];
-  subCategory: number;
-  type: any;
-  typeCode: string;
-  version: string;
-
-  // #endregion Properties (22)
-
-  // #region Public Methods (18)
-
-  addChild(childDevice: ISYNode<any, any, any, any>): void;
-  addLink(isyScene: ISYScene): void;
-  convertFrom(value: any, uom: number): any;
-  convertFrom(value: any, uom: number, propertyName: keyof D): any;
-  convertTo(value: any, uom: number): any;
-  convertTo(value: any, uom: number, propertyName: keyof D): any;
-  handleControlTrigger(controlName: E): boolean;
-  handleEvent(evt: any): unknown;
-  handlePropertyChange(
-    propertyName: keyof D & string,
-    value: any,
-    uom: UnitOfMeasure,
-    prec: number,
-    formattedValue: string
-  ) : boolean;
-  logger(arg0: string): unknown;
-  on(arg0: string, arg1: any): unknown;
-  parseResult(node: { property: DriverState | DriverState[]; }): void;
-  readProperties(): Promise<DriverState[]>;
-  readProperty(propertyName: keyof D): Promise<DriverState>;
-  refresh(): Promise<any>;
-  refreshNotes(): Promise<void>;
-  sendCommand(command: StringKeys<C>, parameters?: Record<string | symbol, string | number> | string | number): Promise<any>;
-  updateProperty(propertyName: StringKeys<D>, value: string): Promise<any>;
-
-  // #endregion Public Methods (18)
+export interface ISYDevice<T extends Family, D extends ISYNode.DriverSignatures, C extends ISYNode.CommandSignatures, E extends ISYNode.EventSignatures> extends ISYDeviceInfo {
+	// #region Properties (22)
+
+	address: string;
+	category: Category;
+	commands: Command.ForAll<C>;
+	deviceClass: any;
+	drivers: Driver.ForAll<D>;
+
+	events: E;
+	enabled: boolean;
+	family: T;
+	hidden: boolean;
+	isDimmable: boolean;
+	label: string;
+	model: string;
+	modelNumber: string;
+	name: any;
+	parentAddress: any;
+	productName: string;
+	scenes: ISYScene[];
+	subCategory: number;
+	type: any;
+	typeCode: string;
+	version: string;
+
+	vendorName: string;
+
+	// #endregion Properties (22)
+
+	// #region Public Methods (18)
+
+	// #endregion Public Methods (18)
+}
+
+export function isDevice<T extends Family, D extends ISYNode.DriverSignatures, C extends ISYNode.CommandSignatures, E extends ISYNode.EventSignatures>(
+	device: ISYNode<T, D, C, E>
+): device is ISYDevice<T, D, C, E> & ISYNode<T, D, C, E> {
+	return device instanceof ISYDeviceNode;
+}
+
+export function isDeviceClass<T extends Family, D extends ISYNode.DriverSignatures, C extends ISYNode.CommandSignatures, E extends ISYNode.EventSignatures>(
+	device: typeof ISYNode<T, D, C, E>
+): device is (new (...args) => ISYDevice<T, D, C, E>) & typeof ISYNode<T, D, C, E> {
+	return device.prototype instanceof ISYDeviceNode;
+}
+
+export interface ISYDeviceInfo {
+	type: string;
+	deviceClass: any;
+
+	productName: string;
+
+	productId: string | number;
+
+	modelName: string;
+
+	modelNumber: string;
+
+	version: string;
+
+	category: Category;
+
+	subCategory: number;
+
+	manufacturer: string;
 }

package/src/ISYNode.ts

@@ -13,10 +13,10 @@ import type { Constructor } from './Devices/Constructor.js';
 import type { DriverState } from './Model/DriverState.js';
 import { NodeInfo } from './Model/NodeInfo.js';
 import type { NodeNotes } from './Model/NodeNotes.js';
-import { type StringKeys } from './Utils.js';
+import { type ObjectToUnion, type StringKeys } from './Utils.js';
 import { NodeType } from './ISYConstants.js';
 import type { ISYScene } from './ISYScene.js';
-import type { UnionToIntersection } from '@matter/general';
+import type { Merge, UnionToIntersection } from '@matter/general';
 
 //type DriverValues<DK extends string | number | symbol,V = any> = {[x in DK]?:V};
 
@@ -41,6 +41,8 @@ export class ISYNode<
 	public static family: Family;
 	public static nodeDefId = 'Unknown';
 
+	public static implements: string[] = [];
+
 	public baseName: any;
 	public commands: Command.ForAll<C>;
 	//public readonly formatted: DriverValues<keyof D,string> = {};
@@ -50,7 +52,7 @@ export class ISYNode<
 	public drivers: Driver.ForAll<D> = {} as Driver.ForAll<D>;
 	public enabled: boolean;
 	//TODO: add signature for non-command/non-driver events
-	public events: Event.FunctionSigFor<E, Event.NodeEventEmitter<this>> & Omit<Event.NodeEventEmitter<this>, 'on'>;
+	public events: Merge<Event.NodeEventEmitter<this>,Event.FunctionSigFor<E, Event.NodeEventEmitter<this>>>;
 	//Event.FunctionSigFor<Event.ForAll<E,typeof this>> & Omit<EventEmitter,'on'>
 	/*{
 		[x in E]: x extends keyof D ? {name:`${D[x]["name"]}Changed`, driver: x, value: D[x]["value"], formatted: string, uom: UnitOfMeasure}
@@ -125,6 +127,7 @@ export class ISYNode<
 		}
 		this.events = Event.createEmitter(this);
 
+
 		//this.logger(this.nodeDefId);
 		this.lastChanged = new Date();
 	}
@@ -222,7 +225,13 @@ export class ISYNode<
 
 	public async getNotes(): Promise<NodeNotes> {
 		try {
-			const result = await this.isy.sendRequest(`nodes/${this.address}/notes`, { trailingSlash: false, errorLogLevel: 'debug', validateStatus(status) { return true; }});
+			const result = await this.isy.sendRequest(`nodes/${this.address}/notes`, {
+				trailingSlash: false,
+				errorLogLevel: 'debug',
+				validateStatus(status) {
+					return true;
+				}
+			});
 			if (result !== null && result !== undefined) {
 				return result.NodeProperties;
 			} else {
@@ -235,7 +244,7 @@ export class ISYNode<
 
 	public handleControlTrigger(controlName: keyof E & keyof C): boolean {
 		//this.lastChanged = new Date();
-		this.events.emit('controlTriggered', controlName);
+		//this.events.emit(`${this.commands[controlName].name}`, controlName);
 		return true;
 	}
 
@@ -343,9 +352,13 @@ export class ISYNode<
 			that.logger(e);
 		}
 	}
-
-	public async sendCommand(command: StringKeys<C>, parameters?: Record<string | symbol, string | number | undefined> | string | number): Promise<any> {
-		//@
+	public async sendCommand(command: StringKeys<C>): Promise<any>;
+	public async sendCommand(command: StringKeys<C>, value: string | number, parameters: Record<string | symbol, string | number | undefined>);
+	public async sendCommand(command: StringKeys<C>, parameters: Record<string | symbol, string | number | undefined> | string | number): Promise<any>;
+	async sendCommand(command: StringKeys<C>, value?: string | number, parameters?: Record<string | symbol, string | number | undefined> | string | number): Promise<any> {
+		if (value !== undefined && typeof parameters === 'object') {
+			return this.isy.sendNodeCommand(this, command, { default: value, ...parameters });
+		}
 		return this.isy.sendNodeCommand(this, command, parameters);
 	}
 
@@ -515,6 +528,17 @@ export namespace ISYNode {
 	export type EventsOf<T> = T extends ISYNode<any, any, any, infer E> ? E : never;
 	export type FamilyOf<T> = T extends ISYNode<infer F, any, any, any> ? F : never;
 
+	export type DriverTypesOf<T extends ISYNode> = ObjectToUnion<DriversOf<T>>;
+
+	export type CommandTypesOf<T extends ISYNode> = ObjectToUnion<CommandsOf<T>>;
+
+	export type EventTypesOf<T extends ISYNode> = ObjectToUnion<EventsOf<T>>;
+
+	export type EventNamesOf<T extends ISYNode> = EventTypesOf<T> extends { name: infer U } ? U : never;
+
+	export type DriverNamesOf<T extends ISYNode> = DriverTypesOf<T> extends { name: infer U } ? U : never;
+
+	export type CommandNamesOf<T extends ISYNode> = CommandTypesOf<T> extends { name: infer U } ? U : never;
 	export type List = NodeList;
 
 	export type DriverMap<T extends NodeList> = Flatten<{

package/src/ISYScene.ts

@@ -1,20 +1,19 @@
-import { Insteon } from './Devices/Insteon/index.js';
+import type { Command } from './Definitions/Global/Commands.js';
+import type { Driver } from './Definitions/Global/Drivers.js';
 import { Family } from './Definitions/Global/Families.js';
+import {Insteon} from './Devices/index.js';
+import type { ISY } from './ISY.js';
 import { Commands, LinkType } from './ISYConstants.js';
+import { ISYDevice } from './ISYDevice.js';
 import { ISYNode } from './ISYNode.js';
-import {  ISYDevice } from './ISYDevice.js';
-import type { ISY } from './ISY.js';
-import type { Driver } from './Definitions/Global/Drivers.js';
-import type { Command } from './Definitions/Global/Commands.js';
 import type { NodeInfo, StaticNodeInfo } from './Model/NodeInfo.js';
 
-interface SceneInfo extends StaticNodeInfo
- {
+interface SceneInfo extends StaticNodeInfo {
 	members?: {
 		link: any;
 	};
 	flag?: any;
-	nodeDefId?: string;
+	nodeDefId?: 'InsteonDimmer';
 	address: string;
 	name: string;
 	family?: Family;
@@ -23,13 +22,12 @@ interface SceneInfo extends StaticNodeInfo
 	startDelay: number;
 }
 
-export class ISYScene extends ISYNode<Family.Scene, Driver.Signatures<'ST'>,Command.Signatures<'DON' | 'DOF'>> {
-
+export class ISYScene extends ISYNode<Family.Scene, Driver.Signatures<'ST'>, Command.Signatures<'DON' | 'DOF'>> {
 	public connectionType: string;
 	public batteryOperated: boolean;
 	public deviceType: any;
 	public deviceFriendlyName: string;
-	public members: ISYDevice<any,any,any>[];
+	public members: ISYNode<any, any, any,any>[];
 	public typeCode: string;
 	constructor(isy: ISY, scene: SceneInfo) {
 		super(isy, scene as NodeInfo);
@@ -47,11 +45,15 @@ export class ISYScene extends ISYNode<Family.Scene, Driver.Signatures<'ST'>,Comm
 					// childDevices.push(node._);
 					// childDevices.push(object)
 					const s = node._;
-					const d = isy.getDevice(s);
+					const d = isy.getNode(s);
 
-					if (d !== null && d !== undefined) { d.addLink(this); }
+					if (d !== null && d !== undefined) {
+						//d.addLink(this);
+					}
 
-					if (d instanceof Insteon.Dimmer && node.type !== LinkType.Controller) { this.isDimmable = true; }
+					if (d instanceof Insteon.DimmerLamp.Node && node.type !== LinkType.Controller) {
+						this.isDimmable = true;
+					}
 					this.members.push(d);
 				}
 			}
@@ -62,11 +64,14 @@ export class ISYScene extends ISYNode<Family.Scene, Driver.Signatures<'ST'>,Comm
 				// childDevices.push(node._);
 				// childDevices.push(object)
 				const s = scene.members.link._;
-				const d = isy.getDevice(s);
-				if (d) { d.addLink(this);
-				// tslint:disable-next-line: triple-equals
-				if ((d.isDimmable && node.type != LinkType.Controller) || this.isDimmable) { this.isDimmable = true; }
-				this.members.push(d);
+				const d = isy.getNode(s);
+				if (d) {
+					//d.addLink(this);
+					// tslint:disable-next-line: triple-equals
+					if ((d.isDimmable && node.type != LinkType.Controller) || this.isDimmable) {
+						this.isDimmable = true;
+					}
+					this.members.push(d);
 				}
 			}
 		}
@@ -76,11 +81,12 @@ export class ISYScene extends ISYNode<Family.Scene, Driver.Signatures<'ST'>,Comm
 	// Get the current light state
 	get isOn() {
 		for (const device of this.members) {
-			if (device instanceof Insteon.Relay)  {
-				if (device.drivers.ST?.value) {
+			let d = device as unknown as ISYNode;
+			/*if (Insteon.RelayLamp.isImplementedBy(d)) {
+				if (d.status > 0) {
 					return true;
 				}
-			}
+			}*/
 		}
 		return false;
 	}
@@ -89,10 +95,10 @@ export class ISYScene extends ISYNode<Family.Scene, Driver.Signatures<'ST'>,Comm
 		let lightDeviceCount = 0;
 		let blevel = 0;
 		for (const device of this.members) {
-			if (device instanceof Insteon.Dimmer) {
+			if (device instanceof Insteon.DimmerSwitch.Node) {
 				lightDeviceCount++;
 				//blevel += device.brightnessLevel;
-			} else if (device instanceof Insteon.Relay) {
+			} else if (device instanceof Insteon.RelayLampSwitch.Node) {
 				lightDeviceCount++;
 				blevel += device.drivers.ST ? 100 : 0;
 			}
@@ -114,7 +120,6 @@ export class ISYScene extends ISYNode<Family.Scene, Driver.Signatures<'ST'>,Comm
 
 		if (this.isDimmable) {
 			this.emit('propertyChanged', 'brightnesslevel', this.brightnessLevel, this.brightnessLevel, this.brightnessLevel + '%');
-
 		}
 	}
 	public async updateIsOn(lightState: boolean) {
@@ -125,7 +130,7 @@ export class ISYScene extends ISYNode<Family.Scene, Driver.Signatures<'ST'>,Comm
 	}
 	public getAreAllLightsInSpecifiedState(state) {
 		for (const device of this.members) {
-			if (device instanceof Insteon.Relay) {
+			if (device instanceof Insteon.RelayLampSwitch.Node) {
 				if (device.drivers.ST !== state) {
 					return false;
 				}
@@ -133,6 +138,4 @@ export class ISYScene extends ISYNode<Family.Scene, Driver.Signatures<'ST'>,Comm
 		}
 		return true;
 	}
-
-
 }

package/src/Matter/Behaviors/BehaviorRegistry.ts

@@ -0,0 +1,26 @@
+import { ClusterBehavior, type Behavior } from '@matter/node';
+import type { RelaxTypes } from '../../Utils.js';
+import type { Constructor } from '../../Devices/Constructor.js';
+
+
+
+export namespace BehaviorRegistry
+{
+
+
+	const registry: {[x:string]: Constructor<ClusterBehavior>} = {};
+
+	type ClusterBehaviorType = RelaxTypes<Omit<typeof ClusterBehavior, "withInterface" | "unimplemented">>;
+
+	export function register<T extends Behavior.Type>(behavior: {cluster: {name: string}} & Constructor<ClusterBehavior>): void
+	{
+		registry[behavior.cluster.name.toLowerCase()] = behavior;
+	}
+
+	export function get(cluster: string): Constructor<ClusterBehavior>
+	{
+		return registry[cluster.toLowerCase()];
+	}
+
+
+}

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

@@ -12,6 +12,8 @@ import { MappingRegistry } from '../../../Model/ClusterMap.js';
 import { ClusterForBehavior, ISYClusterBehavior, type PropertyChange } from '../ISYClusterBehavior.js';
 
 import { Converter } from '../../../Converters.js';
+import { BehaviorRegistry } from '../BehaviorRegistry.js';
+import type { ClusterBehavior } from '@matter/node';
 
 export class ISYOnOffBehavior extends ISYClusterBehavior(OnOffLightRequirements.OnOffServer, InsteonRelayDevice) {
 	override async initialize(_options?: {}) {
@@ -38,6 +40,8 @@ export class ISYOnOffBehavior extends ISYClusterBehavior(OnOffLightRequirements.
 	}
 }
 
+BehaviorRegistry.register(ISYOnOffBehavior);
+
 export class ISYDimmableBehavior extends ISYClusterBehavior(DimmableLightRequirements.LevelControlServer, InsteonDimmableDevice) {
 	override async initialize(_options?: {}) {
 		await super.initialize(_options);
@@ -57,3 +61,5 @@ export class ISYDimmableBehavior extends ISYClusterBehavior(DimmableLightRequire
 
 	}
 }
+
+BehaviorRegistry.register(ISYDimmableBehavior);

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,65 @@
 
-
-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 { Devices } from '../../Devices/index.js';
-import { MappingRegistry, type DeviceToClusterMap, type EndpointMapping, type FamilyToClusterMap } from '../../Model/ClusterMap.js';
+import { Family } from '../../Definitions/Global/Families.js';
+import * as Insteon from '../../Devices/Insteon/index.js';
+import { MappingRegistry, 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 { OnOffLightDevice, DimmableLightDevice } from '@matter/node/devices';
 
 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 +76,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);