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

package/src/Devices/ZigBeeLegacy/Generated/Thermostat.ts

@@ -3,7 +3,7 @@
 import { UnitOfMeasure } from "../../../Definitions/Global/UOM.js";
 import { Family } from "../../../Definitions/Global/Families.js";
 import type { NodeInfo } from "../../../Model/NodeInfo.js";
-import type { ISY } from "../../../ISY.js";
+import { ISY } from "../../../ISY.js";
 import type { ISYNode } from "../../../ISYNode.js";
 import { Base } from "../index.js";
 import { ISYDeviceNode } from "../../ISYDeviceNode.js";
@@ -12,13 +12,13 @@ import { ZigBeeLegacy } from "../../../Definitions/index.js";
 import type { DriverState } from "../../../Model/DriverState.js";
 import { NodeFactory } from "../../NodeFactory.js";
 
-export const nodeDefId = "Thermostat";
+const nodeDefId = "Thermostat";
 
 type Commands = Thermostat.Commands;
 type Drivers = Thermostat.Drivers;
 
 export class ThermostatNode extends Base<Drivers, Commands> implements Thermostat.Interface {
-	public readonly commands = {
+	public override readonly commands = {
 		CLISPH: this.updateHeatSetpoint,
 		CLISPC: this.updateCoolSetpoint,
 		CLIMD: this.updateMode,
@@ -29,7 +29,8 @@ export class ThermostatNode extends Base<Drivers, Commands> implements Thermosta
 		QUERY: this.query,
 		ADRPST: this.adr
 	};
-	static nodeDefId = "Thermostat";
+	static override nodeDefId = "Thermostat";
+	static override implements = ["Thermostat"];
 	declare readonly nodeDefId: "Thermostat";
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
@@ -43,33 +44,15 @@ export class ThermostatNode extends Base<Drivers, Commands> implements Thermosta
 		this.drivers.CLISMD = Driver.create("CLISMD", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Unknown, label: "Schedule Mode", name: "scheduleMode" });
 		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Unknown, label: "Responding", name: "responding" });
 	}
-	async updateHeatSetpoint(value: ) {
-		return this.sendCommand("CLISPH", { value: value });
-	}
-	async updateCoolSetpoint(value: ) {
-		return this.sendCommand("CLISPC", { value: value });
-	}
-	async updateMode(value: ) {
-		return this.sendCommand("CLIMD", { value: value });
-	}
-	async updateFanMode(value: ) {
-		return this.sendCommand("CLIFS", { value: value });
-	}
-	async updateScheduleMode(value: ) {
-		return this.sendCommand("CLISMD", { value: value });
-	}
-	async heatSetpointShift(value: ) {
-		return this.sendCommand("CLISPHD", { value: value });
-	}
-	async coolSetpointShift(value: ) {
-		return this.sendCommand("CLISPCD", { value: value });
-	}
-	async query() {
-		return this.sendCommand("QUERY");
-	}
-	async adr(value: ) {
-		return this.sendCommand("ADRPST", { value: value });
-	}
+	async updateHeatSetpoint(value: ) { return this.sendCommand("CLISPH", { value: value }); }
+	async updateCoolSetpoint(value: ) { return this.sendCommand("CLISPC", { value: value }); }
+	async updateMode(value: ) { return this.sendCommand("CLIMD", { value: value }); }
+	async updateFanMode(value: ) { return this.sendCommand("CLIFS", { value: value }); }
+	async updateScheduleMode(value: ) { return this.sendCommand("CLISMD", { value: value }); }
+	async heatSetpointShift(value: ) { return this.sendCommand("CLISPHD", { value: value }); }
+	async coolSetpointShift(value: ) { return this.sendCommand("CLISPCD", { value: value }); }
+	async query() { return this.sendCommand("QUERY"); }
+	async adr(value: ) { return this.sendCommand("ADRPST", { value: value }); }
 	public get temperature(): {
         
 return this.drivers.ST?.value;
@@ -122,8 +105,9 @@ export namespace Thermostat {
 	export interface Interface extends Omit<InstanceType<typeof ThermostatNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "Thermostat";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is ThermostatNode {
-		return node.nodeDefId === nodeDefId;
+	export function is(node: ISYNode<any, any, any, any>): node is ThermostatNode { return ["Thermostat"].includes(node.nodeDefId); }
+	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is ThermostatNode {
+		return ["Thermostat"].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new ThermostatNode(isy, nodeInfo);

package/src/Devices/index.ts

@@ -1,24 +1,29 @@
-
 import type { Family } from '../Definitions/index.js';
-import {Insteon} from "./Insteon/index.js";
-import { ZWaveBaseDevice } from "./ZWave/ZWaveBaseDevice.js";
+import * as Insteon from './Insteon/index.js';
+import { NodeFactory } from './NodeFactory.js';
+import { ZWaveBaseDevice } from './ZWave/ZWaveBaseDevice.js';
+import * as ZWave from './ZWave/index.js';
 
 export const Devices = {
-  Insteon: Insteon,
-  ZWave: { Base: ZWaveBaseDevice },
-  ZigBee: {},
+	Insteon: Insteon,
+	ZWave: { Base: ZWaveBaseDevice },
+	ZigBee: {}
+};
+Insteon.AlertModuleArmed.Node
+
+export * as Insteon from './Insteon/index.js';
+export * as ZWave from './ZWave/index.js';
 
-}
 
 export namespace Devices {
-  export type Insteon = typeof Insteon;
-  export type ZWave = { Base: ZWaveBaseDevice };
-  export type ZigBee = {};
+	export type Insteon = typeof Insteon;
+	export type ZWave = typeof ZWave;
+	export type ZigBee = {};
 }
 
-
 export type Devices<T extends Family.Insteon | Family.ZWave | Family.ZigBee> = (typeof Devices)[`Insteon`];
 
-export type ToDevice<T extends keyof Devices<any>> = T extends keyof Devices<infer B> ? Devices<B>[`${T}`] : never;
+/*export type ToDevice<T extends keyof Devices<any>> = T extends keyof Devices<infer B> ? Devices<B>[`${T}`] : never;*/
 
+NodeFactory.sortImplementsRegistry();
 export default Devices;

package/src/ISY.ts

@@ -470,12 +470,18 @@ export class ISY extends EventEmitter implements Disposable {
 	}
 
 	public async loadVariables(type: VariableType): Promise<any> {
+		try
+		{
 		const that = this;
 		this.logger.info(`Loading ISY Variables of type: ${type}`);
 		return this.sendRequest(`vars/definitions/${type}`)
 			.then((result) => that.#createVariables(type, result))
 			.then(() => that.sendRequest(`vars/get/${type}`))
 			.then(that.#setVariableValues.bind(that));
+		}
+		catch{
+			this.logger.warn('error loading variables');
+		}
 	}
 
 	public nodeChangedHandler(node: ELKAlarmPanelDevice | ElkAlarmSensorDevice, propertyName = null) {
@@ -531,12 +537,12 @@ export class ISY extends EventEmitter implements Disposable {
 		if (parameters !== null && parameters !== undefined) {
 			if (typeof parameters == 'object') {
 				var q = parameters as Record<P, string | number>;
-				for (const paramName of Object.getOwnPropertyNames(q)) {
+				for (const paramName in q) {
 					if (paramName === 'value') {
 						uriToUse += `/${q[paramName]}`;
 						continue;
 					}
-					if (typeof q[paramName] === 'string' || typeof q[paramName] === 'number') uriToUse += `/${paramName}/${q[paramName]}`;
+					else if (typeof q[paramName] === 'string' || typeof q[paramName] === 'number') 		uriToUse += `/${paramName}/${q[paramName]}`;
 				}
 
 				//uriToUse += `/${q[((p : Record<string,number|number>) => `${p[]}/${p.paramValue}` ).join('/')}`;

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);