isy-nodejs 1.0.1-alpha.5 → 1.0.1-alpha.9

package/src/Matter/Behaviors/ISYClusterBehavior.ts

@@ -1,38 +1,50 @@
-import type { ClusterBehavior, ClusterInterface } from '@project-chip/matter.js/behavior/cluster';
-
-import type { DriversOf, ISYNode } from '../../ISYNode.js';
-
 import type { Behavior } from '@project-chip/matter.js/behavior';
+import type { ClusterBehavior, ClusterInterface } from '@project-chip/matter.js/behavior/cluster';
 import { BridgedDeviceBasicInformationServer } from '@project-chip/matter.js/behaviors/bridged-device-basic-information';
 import type { LevelControlBehavior } from '@project-chip/matter.js/behaviors/level-control';
 import type { OnOffBehavior, OnOffServer } from '@project-chip/matter.js/behaviors/on-off';
 import type { Cluster, ClusterServerHandlers, ClusterType as CT } from '@project-chip/matter.js/cluster';
 import '@project-chip/matter.js/device';
 import { OnOffLightRequirements } from '@project-chip/matter.js/devices/OnOffLightDevice';
-import { DriverType } from '../../Definitions/Global/Drivers.js';
+import { Converter } from '../../Converters.js';
+import { Driver, DriverType } from '../../Definitions/Global/Drivers.js';
 import type { Constructor } from '../../Devices/Constructor.js';
 import type { RelaxTypes } from '../../Devices/MapsTo.js';
 import { ISY, type ISYDevice } from '../../ISY.js';
-import { MappingRegistry, type ClusterMapping, type DeviceToClusterMap } from '../../Model/ClusterMap.js';
-
+import type { DriversOf, ISYNode } from '../../ISYNode.js';
+import { BehaviorMapping, MappingRegistry, type ClusterMapping, type DeviceToClusterMap } from '../../Model/ClusterMap.js';
 import { ISYBridgedDeviceBehavior } from './ISYBridgedDeviceBehavior.js';
 
-type NotUnknown<T extends ClusterBehavior> = T extends { cluster: { name: 'Unknown' } } ? never : T;
+// #region Type aliases (6)
 
+export type ClusterForBehavior<B> = B extends ClusterBehavior.Type<infer C, infer D, infer E> ? C : never;
 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, T extends { cluster? }> = {
+	device: P;
 
-export type ClusterForBehavior<B> = B extends ClusterBehavior.Type<infer C, infer D, infer E> ? C : never;
+	bridgedDeviceBehavior: ISYBridgedDeviceBehavior<P>;
 
-type t = ClusterForBehavior<LevelControlBehavior>;
+	//ts-ignore
+	map: BehaviorMapping<T, P>;
 
+	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>> = {
 	driver: keyof DriversOf<P>;
 	newValue: any;
 	oldValue: any;
 	formattedValue: string;
 };
+type t = ClusterForBehavior<LevelControlBehavior>;
+
+// #endregion Type aliases (6)
 
-export function ISYClusterBehavior<T extends Constructor<ClusterBehavior> & { cluster: unknown }, P extends ISYNode<any, any, any, any>>(
+// #region Functions (1)
+
+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> } {
@@ -41,30 +53,44 @@ export function ISYClusterBehavior<T extends Constructor<ClusterBehavior> & { cl
 
 		handlers: { [x in keyof DriversOf<P>]: (newValue, oldValue, formattedValue) => void } = {} as any;
 
+		bridgedDeviceBehavior: ISYBridgedDeviceBehavior<P>;
 		///public map: ClusterMapping<ToClusterTypeByName<ClusterForBehavior<ConstructedType<typeof base>>["name"]>,ISYDeviceNode<any, any, any>>;
 
-		map: ClusterMapping<T['cluster'], P>;
+		map: BehaviorMapping<T, P>;
 
 		override async initialize(_options?: {}) {
 			await super.initialize(_options);
-			var behavior = await this.agent.load(ISYBridgedDeviceBehavior);
+			var behavior = (await this.agent.load(ISYBridgedDeviceBehavior)) as ISYBridgedDeviceBehavior<P>;
+			this.bridgedDeviceBehavior = behavior;
 			//var behavior = this.agent.get(ISYBridgedDeviceBehavior);
 			this._device = behavior.device as P;
+			//@ts-ignore
 			this.map = behavior.mapForBehavior<T>(this as unknown as T);
 			for (const key2 in this.map.attributes) {
-				if (typeof this.map.attributes[key2] === 'string') {
-					this.handlers[this.map.attributes[key2]] = (newValue, oldValue, formattedValue) => {
+				let val = this.map.attributes[key2];
+				let driverObj = null;
+				if (typeof val === 'string' || typeof val === 'symbol' || typeof val === 'number') {
+					driverObj = this._device.drivers[val];
+					this.handlers[val] = (newValue, oldValue, formattedValue) => {
 						this.state[key2 as string] = newValue;
 					};
-				} else if (this.map.attributes[key2].driver) {
-					let { driver, converter } = this.map.attributes[key2];
+				} else if (val.driver as DriversOf<P>) {
+					driverObj = this._device.drivers[val.driver as string];
+
+					let { driver, converter } = val;
+					const convFunc = Converter.get(converter)?.from;
 					this.handlers[driver] = (newValue, oldValue, formattedValue) => {
-						this.state[key2 as string] = converter(newValue);
+						if (convFunc) this.state[key2 as string] = convFunc(newValue);
+						else this.state[key2 as string] = newValue;
 					};
 				}
+				if (driverObj) {
+					let evt = `${driverObj.name}Changed`;
+					this.reactTo(behavior.events[evt], this.handlePropertyChange.bind(this), { lock: false });
+				}
 			}
 
-			this.reactTo(behavior.events.propertyChanged, this.handlePropertyChange, { lock: false });
+			//this.reactTo(behavior.events.propertyChanged, this.handlePropertyChange, { lock: false });
 
 			//this._device.on("PropertyChanged", this.handlePropertyChange.bind(this));
 		}
@@ -95,13 +121,5 @@ export function ISYClusterBehavior<T extends Constructor<ClusterBehavior> & { cl
 		}
 	};
 }
-// <reference path="MatterDevice.js" />
-// @ts-ignore
-
-export type DeviceBehavior<P extends ISYNode, T extends { cluster }> = {
-	device: P;
 
-	map: ClusterMapping<T['cluster'], P>;
-
-	handlePropertyChange(chg: PropertyChange<P>): void;
-};
+// #endregion Functions (1)

package/src/Matter/Behaviors/ISYOnOffBehavior.ts

@@ -1,80 +1,69 @@
-import { InsteonRelayDevice } from "../../Devices/Insteon/InsteonRelayDevice.js"
-import { OnOffLightRequirements } from "@project-chip/matter.js/devices/OnOffLightDevice";
-import { ISYClusterBehavior, ClusterForBehavior, type PropertyChange } from "./ISYClusterBehavior.js";
+import type { LevelControlInterface, LevelControlServer } from '@project-chip/matter.js/behaviors/level-control';
+import type { OnOffBehavior, OnOffServer } from '@project-chip/matter.js/behaviors/on-off';
+import type { MutableCluster, OnOffCluster } from '@project-chip/matter.js/cluster';
+import { DimmableLightRequirements } from '@project-chip/matter.js/devices/DimmableLightDevice';
+import { OnOffLightRequirements } from '@project-chip/matter.js/devices/OnOffLightDevice';
 import { OnOffLightSwitchDevice } from '@project-chip/matter.js/devices/OnOffLightSwitchDevice';
 import type { MaybePromise } from '@project-chip/matter.js/util';
-import { MappingRegistry } from '../../Model/ClusterMap.js';
-import type { MutableCluster, OnOffCluster } from '@project-chip/matter.js/cluster';
-import type { OnOffBehavior, OnOffServer } from '@project-chip/matter.js/behaviors/on-off';
-import type { LevelControlServer, LevelControlInterface } from '@project-chip/matter.js/behaviors/level-control';
 import { DriverType } from '../../Definitions/Global/Drivers.js';
-import { DimmableLightRequirements } from '@project-chip/matter.js/devices/DimmableLightDevice';
 import { InsteonDimmableDevice } from '../../Devices/Insteon/InsteonDimmableDevice.js';
+import { InsteonRelayDevice } from '../../Devices/Insteon/InsteonRelayDevice.js';
+import { MappingRegistry } from '../../Model/ClusterMap.js';
+import { ClusterForBehavior, ISYClusterBehavior, type PropertyChange } from './ISYClusterBehavior.js';
 
-import {Converters} from '../../Converters.js';
-
-
-
-
-
-export class ISYOnOffBehavior extends ISYClusterBehavior(OnOffLightRequirements.OnOffServer, InsteonRelayDevice)
-{
-
-    override async initialize(_options?: {}) {
-        await super.initialize(_options);
-        //this.state.onOff = await this.device.state;
-
-
+import { Converter } from '../../Converters.js';
 
-    }
+export class ISYOnOffBehavior extends ISYClusterBehavior(OnOffLightRequirements.OnOffServer, InsteonRelayDevice) {
+	override async initialize(_options?: {}) {
+		await super.initialize(_options);
+		//this.state.onOff = await this.device.state;
+	}
 
+	override on = async () => {
+		await super.on();
+		await this.device.on();
 
-  override on = async () => {
-    await super.on();
+		//this.device.commands.DON = true;
+	};
 
+	override async off() {
+		await super.off();
+		await this.device.off();
 
-     //this.device.commands.DON = true;
-  }
 
-  override async off() {
-    //await super.off();
-    // this.device.drivers = false;
-  }
 
-  override toggle =  async () => {
-    //this.device.state = !(await this.device.state);
-  }
+		// this.device.drivers = false;
+	}
 
-  override async handlePropertyChange({driver, newValue, oldValue, formattedValue}: PropertyChange<InsteonRelayDevice>) {
-    if (driver === "ST") {
-      this.state.onOff = newValue;
+	override toggle = async () => {
 
-    }
+		//this.device.state = !(await this.device.state);
+	};
 
-    return super.handlePropertyChange({driver, newValue, oldValue, formattedValue});
-  }
+	override async handlePropertyChange({ driver, newValue, oldValue, formattedValue }: PropertyChange<InsteonRelayDevice>) {
+		/*if (driver === 'ST') {
+			this.state.onOff = newValue;
+		}*/
 
 
+		return super.handlePropertyChange({ driver, newValue, oldValue, formattedValue });
+	}
 }
 
-
 export class ISYDimmableBehavior extends ISYClusterBehavior(DimmableLightRequirements.LevelControlServer, InsteonDimmableDevice) {
-  override async initialize(_options?: {}) {
-    await super.initialize(_options);
-    this.state.currentLevel = this.device.drivers.ST.value;
-    //this.state.onLevel = this.device.drivers.OL;
-
-  }
-
-  override setLevel(level: number): MaybePromise<void> {
-    level = Converters.Matter.LevelFrom0To255.LightingLevel.to(level);
-    if(level > 0)
-    {
-        return this.device.sendCommand('DON',level);
-    }
-    else
-    {
-        return this.device.sendCommand('DOF');
-    }
-  }
-}
+	override async initialize(_options?: {}) {
+		await super.initialize(_options);
+		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.sendCommand('DON', level);
+		} else {
+			return this.device.sendCommand('DOF');
+		}
+	}
+}

package/src/Matter/{Server → Bridge}/Server.ts

@@ -1,5 +1,7 @@
+import '@project-chip/matter-node.js';
 import { NodeJsEnvironment } from '@project-chip/matter-node.js/environment';
 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';
@@ -8,42 +10,47 @@ import { DimmableLightDevice, OnOffLightDevice } from '@project-chip/matter.js/e
 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 { Environment, StorageService } from '@project-chip/matter.js/environment';
+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 { QrCode } from '@project-chip/matter.js/schema';
 import { resolve } from 'path';
-import { config } from 'winston';
 import { InsteonDimmableDevice, InsteonKeypadButtonDevice, InsteonRelayDevice, ISY } from '../../ISY.js';
 import { ISYBridgedDeviceBehavior } from '../Behaviors/ISYBridgedDeviceBehavior.js';
 import { ISYDimmableBehavior, ISYOnOffBehavior } from '../Behaviors/ISYOnOffBehavior.js';
+import '../Mappings/Insteon.js';
+import type { ISYDeviceNode } from '../../Devices/ISYDeviceNode.js';
 
-// #region Functions (2)
+// #region Interfaces (1)
 
-//import {clone} from 'isy-nodejs/Utils';
-//let { Utils } = await import ('isy-nodejs');
+export interface Config {
+	// #region Properties (8)
 
-// function plainLogFormatter(now: Date, level: Level, facility: string, prefix: string, values: any[]) {
-//     const creator = plaintextCreator();
+	discriminator: number;
+	passcode: number;
+	port: number;
+	productId: number;
+	productName?: string;
+	uniqueId: string;
+	vendorId: number;
+	vendorName?: string;
 
-//     const formattedValues = renderDiagnostic(values, {
-//         ...creator,
-//         key: text => creator.text(`${text}: `),
-//         value: producer => creator.text(producer()),
-//         strong: producer => creator.text(`*${producer()}*`),
-//         weak: producer => creator.text(producer()),
-//         status: (status, producer) => `${creator.text(statusIcon(status))}${producer()}`,
-//         via: text => creator.text(text),
-//     });
+	// #endregion Properties (8)
+}
+
+// #endregion Interfaces (1)
 
-//     return `${formatTime(now)} ${Level[level]} ${facility} ${prefix}${formattedValues}`;
-//
+// #region Functions (3)
 
-//let matterLogger = clone(logger,'matter.js');
+export function create(isy?: ISY, config?: Config): Promise<ServerNode> {
+	return createMatterServer(isy, config);
+}
 
-//2024-07-03 16:30:43.693
-export async function createServerNode(isy: ISY = ISY.instance): Promise<ServerNode> {
+export async function createMatterServer(isy?: ISY, config?: Config): Promise<ServerNode> {
 	var logger = isy.logger;
+	if (isy === undefined) {
+		isy = ISY.instance;
+	}
 
 	try {
 		MatterLogger.addLogger(
@@ -58,7 +65,7 @@ export async function createServerNode(isy: ISY = ISY.instance): Promise<ServerN
 		MatterLogger.defaultLogLevel = levelFromString(logger.level);
 	}
 
-	var config = await getConfiguration(isy);
+	config = await initializeConfiguration(isy, config);
 
 	logger.info(`Matter config read: ${JSON.stringify(config)}`);
 
@@ -70,6 +77,7 @@ export async function createServerNode(isy: ISY = ISY.instance): Promise<ServerN
 		// Optional when operating only one device on a host, Default port is 5540
 		network: {
 			port: config.port,
+
 			//ipv4: false,
 			discoveryCapabilities: {
 				onIpNetwork: true
@@ -124,7 +132,8 @@ export async function createServerNode(isy: ISY = ISY.instance): Promise<ServerN
 
 	const endpoints: { 0: Endpoint; 1: InsteonRelayDevice }[] = [];
 
-	for (const device of isy.deviceList.values()) {
+	for (const node of isy.nodeMap.values()) {
+		let device = node as ISYDeviceNode<any, any, any>;
 		let serialNumber = `${device.address.replaceAll(' ', '_').replaceAll('.', '_')}`;
 		if (device.enabled && !(device instanceof InsteonKeypadButtonDevice)) {
 			//const name = `OnOff ${isASocket ? "Socket" : "Light"} ${i}`;
@@ -147,6 +156,7 @@ export async function createServerNode(isy: ISY = ISY.instance): Promise<ServerN
 			}
 
 			if (baseBehavior !== undefined) {
+				//@ts-ignore
 				const endpoint = new Endpoint(baseBehavior, {
 					id: serialNumber,
 					isyNode: {
@@ -190,9 +200,13 @@ export async function createServerNode(isy: ISY = ISY.instance): Promise<ServerN
 	 * 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.bringOnline();
+	await server.start();
 
 	logger.info('Matter Server is online');
 	/**
@@ -216,34 +230,20 @@ export async function createServerNode(isy: ISY = ISY.instance): Promise<ServerN
 		logger.info(`Manual pairing code: ${manualPairingCode}`);
 	}
 	/*for(let e of endpoints)
-    {
-      e[1].initialize(e[0] as any);
-    }*/
+	{
+	  e[1].initialize(e[0] as any);
+	}*/
 
 	return server;
-
-	function createBaseBehavior(): any {
-		let baseBehavior: any;
-		return baseBehavior;
-	}
 }
 
-async function getConfiguration(isy: ISY) {
+async function initializeConfiguration(isy: ISY, config?: Config): Promise<Config> {
 	var logger = isy.logger;
-	/**
-	 * Collect all needed data
-	 *
-	 * This block collects all needed data from cli, environment or storage. Replace this with where ever your data come from.
-	 *
-	 * Note: This example uses the matter.js process storage system to store the device parameter data for convenience
-	 * and easy reuse. When you also do that be careful to not overlap with Matter-Server own storage contexts
-	 * (so maybe better not do it ;-)).
-	 */
 
 	const environment = NodeJsEnvironment();
 
 	const storageService = environment.get(StorageService);
-	environment.vars.set('storage.path', ISY.instance.storagePath + '/matter');
+	environment.vars.set('storage.path', `${ISY.instance.storagePath}matter`);
 	environment.vars.use(() => {
 		const location = environment.vars.get('storage.path', environment.vars.get('path.root', '.'));
 		storageService.location = location;
@@ -254,15 +254,15 @@ async function getConfiguration(isy: ISY) {
 	const deviceStorage = (await storageService.open('device')).createContext('data');
 
 	const vendorName = isy.vendorName;
-	const passcode = environment.vars.number('passcode') ?? (await deviceStorage.get('passcode', 20202021));
-	const discriminator = environment.vars.number('discriminator') ?? (await deviceStorage.get('discriminator', 3840));
+	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));
 	// product name / id and vendor id should match what is in the device certificate
-	const vendorId = environment.vars.number('vendorid') ?? (await deviceStorage.get('vendorid', 0xfff1));
-	const productId = environment.vars.number('productid') ?? (await deviceStorage.get('productid', 0x8000));
+	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 = environment.vars.number('port') ?? 5540;
+	const port = config.port ?? environment.vars.number('port') ?? 5540;
 
-	const uniqueId = isy.id;
+	const uniqueId = isy.id.replaceAll(':', '_');
 	//environment.vars.string("uniqueid") ?? (await deviceStorage.get("uniqueid", Time.nowMs().toString()));
 
 	// Persist basic data to keep them also on restart
@@ -287,4 +287,4 @@ async function getConfiguration(isy: ISY) {
 	};
 }
 
-// #endregion Functions (2)
+// #endregion Functions (3)

package/src/Matter/Mappings/Insteon.ts

@@ -1,68 +1,61 @@
-import { OnOffCluster } from "@project-chip/matter.js/cluster";
-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 FamilyToClusterMap,
-  type DeviceToClusterMap,
-  type EndpointMapping
-} from "../../Model/ClusterMap.js";
-import { DeviceTypeDefinition, DeviceTypes, OnOffBaseDevice } from "@project-chip/matter.js/device";
-import { OnOffLightDevice } from "@project-chip/matter.js/devices/OnOffLightDevice";
+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';
+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 InsteonMap from "./Insteon.json";
-import { DimmableLightDevice } from "@project-chip/matter.js/devices/DimmableLightDevice";
-import { Converters } from '../../Converters.js';
+import { DimmableLightDevice } from '@project-chip/matter.js/devices/DimmableLightDevice';
+import { Converter } from '../../Converters.js';
 import type { InsteonRelaySwitchDevice } from '../../Devices/Insteon/InsteonRelaySwitchDevice.js';
 
-
-
 const map: FamilyToClusterMap<Family.Insteon> = {
-  Relay: {
-    deviceType: OnOffLightDevice,
-    mapping:  {
-
-      OnOff: {
-        attributes: {
-          onOff: { driver: "ST"},
-        },
-        commands: { on: 'DON'},
-      },
-
-
-
-    }
-  } ,
-  RelaySwitch: {
-    deviceType: OnOffLightDevice,
-    mapping: {
-      OnOff: {
-        attributes: {
-          onOff: "ST",
-        },
-        commands: { on: "DON"},
-      },
-    },
-  } ,
-  Dimmer: {
-    deviceType: DimmableLightDevice,
-    mapping: {
-      OnOff: {
-        attributes: {
-          onOff: { driver: "ST" },
-        },
-        commands: { on: "DON" },
-      },
-      LevelControl: {
-        attributes: {
-          currentLevel: { driver: DriverType.Status },
-        },
-        commands: { moveToLevel: {command: 'DON'}},
-      },
-    },
-  },
+	Family: Family.Insteon,
+	Relay: {
+		deviceType: OnOffLightDevice,
+		mapping: {
+			OnOff: {
+				attributes: {
+					onOff: { driver: 'ST', converter: 'Percent.Boolean' }
+				},
+				commands: { on: 'DON' }
+			}
+		} as EndpointMapping<OnOffLightDevice, Insteon.Relay>
+	},
+	RelaySwitch: {
+		deviceType: OnOffLightDevice,
+		mapping: {
+			OnOff: {
+				attributes: {
+					onOff: 'ST'
+				},
+				commands: { on: 'DON' }
+			}
+		}
+	},
+	Dimmer: {
+		deviceType: DimmableLightDevice,
+		mapping: {
+			OnOff: {
+				attributes: {
+					onOff: { driver: 'ST', converter: 'LevelFrom0To255.Boolean' }
+				},
+				commands: { on: 'DON' }
+			},
+			LevelControl: {
+				attributes: {
+					currentLevel: { driver: DriverType.Status, converter: 'LevelFrom0To255.LightingLevel' }
+				},
+				commands: { moveToLevel: { command: 'DON' } }
+			}
+		}
+	}
 };
 
+map.KeypadDimmer = map.Dimmer;
+map.DimmerSwitch = map.Dimmer;
+
 MappingRegistry.register(map);

package/src/Model/ClassDefinition.ts

@@ -1,7 +1,7 @@
 import { camelize, capitalize } from '@project-chip/matter.js/util';
 import camelcase from 'camelcase';
 import { getRandomValues } from 'crypto';
-import { detailedDiff } from 'deep-object-diff';
+//import { detailedDiff } from 'deep-object-diff';
 import { create } from 'domain';
 import * as fs from 'fs';
 import diff from 'microdiff';