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

package/src/Devices/Insteon/KeypadButton.ts

@@ -1,18 +1,18 @@
 /* THIS FILE WAS AUTOMATICALLY GENERATED. DO NOT EDIT DIRECTLY. */
 
-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 type { ISYNode } from "../../ISYNode.js";
-import { Base } from "./index.js";
-import { ISYDeviceNode } from "../ISYDeviceNode.js";
-import { Driver } from "../../Definitions/Global/Drivers.js";
-import { Insteon } from "../../Definitions/index.js";
-import type { DriverState } from "../../Model/DriverState.js";
-import { NodeFactory } from "../NodeFactory.js";
+import { Driver } from '../../Definitions/Global/Drivers.js';
+import { Family } from '../../Definitions/Global/Families.js';
+import { UnitOfMeasure } from '../../Definitions/Global/UOM.js';
+import { Insteon } from '../../Definitions/index.js';
+import type { ISY } from '../../ISY.js';
+import type { ISYNode } from '../../ISYNode.js';
+import type { DriverState } from '../../Model/DriverState.js';
+import type { NodeInfo } from '../../Model/NodeInfo.js';
+import { ISYDeviceNode } from '../ISYDeviceNode.js';
+import { NodeFactory } from '../NodeFactory.js';
+import { Base } from './index.js';
 
-export const nodeDefId = "KeypadButton";
+export const nodeDefId = 'KeypadButton';
 
 type Commands = KeypadButton.Commands;
 type Drivers = KeypadButton.Drivers;
@@ -23,21 +23,21 @@ export class KeypadButtonNode extends Base<Drivers, Commands> implements KeypadB
 		BL: this.backlight,
 		WDU: this.writeChanges
 	};
-	static override nodeDefId = "KeypadButton";
-	declare readonly nodeDefId: "KeypadButton";
-	constructor (isy: ISY, nodeInfo: NodeInfo) {
+	static override nodeDefId = 'KeypadButton';
+	declare readonly nodeDefId: 'KeypadButton';
+	constructor(isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
-		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
+		this.drivers.ST = Driver.create('ST', this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: 'Status', name: 'status' });
+		this.drivers.ERR = Driver.create('ERR', this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: 'Responding', name: 'responding' });
 	}
 	async query() {
-		return this.sendCommand("QUERY");
+		return this.sendCommand('QUERY');
 	}
 	async backlight(value: number) {
-		return this.sendCommand("BL", { value: value });
+		return this.sendCommand('BL', { value: value });
 	}
 	async writeChanges() {
-		return this.sendCommand("WDU");
+		return this.sendCommand('WDU');
 	}
 	public get status(): Insteon.OnLevelRelay {
 		return this.drivers.ST?.value;
@@ -51,7 +51,7 @@ NodeFactory.register(KeypadButtonNode);
 
 export namespace KeypadButton {
 	export interface Interface extends Omit<InstanceType<typeof KeypadButtonNode>, keyof ISYDeviceNode<any, any, any, any>> {
-		nodeDefId: "KeypadButton";
+		nodeDefId: 'KeypadButton';
 	}
 	export function is(node: ISYNode<any, any, any, any>): node is KeypadButtonNode {
 		return node.nodeDefId === nodeDefId;
@@ -62,30 +62,30 @@ export namespace KeypadButton {
 	export const Node = KeypadButtonNode;
 	export type Commands = {
 		QUERY: (() => Promise<boolean>) & {
-			label: "Query";
-			name: "query";
+			label: 'Query';
+			name: 'query';
 		};
 		BL: ((value: number) => Promise<boolean>) & {
-			label: "Backlight";
-			name: "backlight";
+			label: 'Backlight';
+			name: 'backlight';
 		};
 		WDU: (() => Promise<boolean>) & {
-			label: "Write Changes";
-			name: "writeChanges";
+			label: 'Write Changes';
+			name: 'writeChanges';
 		};
 	};
 	export type Drivers = {
 		ST: {
 			uom: UnitOfMeasure.Percent;
 			value: Insteon.OnLevelRelay;
-			label: "Status";
-			name: "status";
+			label: 'Status';
+			name: 'status';
 		};
 		ERR: {
 			uom: UnitOfMeasure.Index;
 			value: Insteon.Error;
-			label: "Responding";
-			name: "responding";
+			label: 'Responding';
+			name: 'responding';
 		};
 	};
 }

package/src/Devices/Insteon/index.ts

@@ -13,39 +13,31 @@ import { InsteonRelaySwitchDevice } from "./InsteonRelaySwitchDevice.js";
 import { InsteonThermostatDevice } from "./InsteonThermostatDevice.js";
 import { InsteonDoorWindowSensorDevice } from './InsteonDoorWindowSensorDevice.js';
 
+import { ISYNode } from '../../ISYNode.js';
+import type * as GeneratedTypes from "./Generated/index.js";
+
 export {InsteonBaseDevice as Base} from  "./InsteonBaseDevice.js";
 
+export {InsteonLeakSensorDevice as LeakSensor} from "./InsteonLeakSensorDevice.js";
+
+export {InsteonMotionSensorDevice as MotionSensor} from "./InsteonMotionSensorDevice.js";
+
+export {InsteonSmokeSensorDevice as SmokeSensor} from "./InsteonSmokeSensorDevice.js";
+
+export {InsteonDoorWindowSensorDevice as DoorWindowSensor} from "./InsteonDoorWindowSensorDevice.js";
 
-export const Insteon = {
+export {InsteonDimmerOutletDevice as DimmerOutlet} from "./InsteonDimmerOutletDevice.js";
+
+/*export const Insteon = {
   LeakSensor: InsteonLeakSensorDevice,
   MotionSensor: InsteonMotionSensorDevice,
   SmokeSensor: InsteonSmokeSensorDevice,
-  RelaySwitch: InsteonRelaySwitchDevice,
   DoorWindowSensor: InsteonDoorWindowSensorDevice,
-  DimmerSwitch: InsteonDimmerSwitchDevice,
   DimmerOutlet: InsteonDimmerOutletDevice,
-
-  Relay: InsteonRelayDevice,
-  Dimmer: InsteonDimmableDevice,
-  KeypadDimmer: InsteonKeypadDimmerDevice,
   Thermostat: InsteonThermostatDevice,
   Lock: InsteonLockDevice,
-  Fan: InsteonFanDevice
-};
-
-
-export namespace Insteon {
-  //export type Base<D,C> = InsteonBaseDevice<D,C>;
-  export type LeakSensor = InsteonLeakSensorDevice;
-  export type MotionSensor = InsteonMotionSensorDevice;
-  export type SmokeSensor = InsteonSmokeSensorDevice;
-  export type RelaySwitch = InsteonRelaySwitchDevice;
-  export type DimmerSwitch = InsteonDimmerSwitchDevice;
-  export type DimmerOutlet = InsteonDimmerOutletDevice;
-  export type Relay = InsteonRelayDevice;
-  export type Dimmer = InsteonDimmableDevice;
-  export type KeypadDimmer = InsteonKeypadDimmerDevice;
-  export type Thermostat = InsteonThermostatDevice;
-  export type Lock = InsteonLockDevice;
-  export type Fan = InsteonFanDevice;
-}
+  Fan: InsteonFanDevice,
+...Generated */
+
+
+export * from './Generated/index.js';

package/src/Devices/Lutron/Generated/LoadShed.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,33 +12,28 @@ import { Lutron } from "../../../Definitions/index.js";
 import type { DriverState } from "../../../Model/DriverState.js";
 import { NodeFactory } from "../../NodeFactory.js";
 
-export const nodeDefId = "LUTLoadShed";
+const nodeDefId = "LUTLoadShed";
 
 type Commands = LoadShed.Commands;
 type Drivers = LoadShed.Drivers;
 
 export class LoadShedNode extends Base<Drivers, Commands> implements LoadShed.Interface {
-	public readonly commands = {
+	public override readonly commands = {
 		DON: this.on,
 		DOF: this.off,
 		QUERY: this.query
 	};
-	static nodeDefId = "LUTLoadShed";
+	static override nodeDefId = "LUTLoadShed";
+	static override implements = ["LUTLoadShed"];
 	declare readonly nodeDefId: "LUTLoadShed";
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
 		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
 		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
-	async on(value?: (0 | 100)) {
-		return this.sendCommand("DON", { value: value });
-	}
-	async off() {
-		return this.sendCommand("DOF");
-	}
-	async query() {
-		return this.sendCommand("QUERY");
-	}
+	async on(value?: (0 | 100)) { return this.sendCommand("DON", { value: value }); }
+	async off() { return this.sendCommand("DOF"); }
+	async query() { return this.sendCommand("QUERY"); }
 	public get status(): (0 | 100) {
 		return this.drivers.ST?.value;
 	}
@@ -53,8 +48,9 @@ export namespace LoadShed {
 	export interface Interface extends Omit<InstanceType<typeof LoadShedNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "LUTLoadShed";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is LoadShedNode {
-		return node.nodeDefId === nodeDefId;
+	export function is(node: ISYNode<any, any, any, any>): node is LoadShedNode { return ["LUTLoadShed"].includes(node.nodeDefId); }
+	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is LoadShedNode {
+		return ["LUTLoadShed"].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new LoadShedNode(isy, nodeInfo);

package/src/Devices/NCD/Generated/Relay.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,37 +12,30 @@ import { NCD } from "../../../Definitions/index.js";
 import type { DriverState } from "../../../Model/DriverState.js";
 import { NodeFactory } from "../../NodeFactory.js";
 
-export const nodeDefId = "NCDRelay";
+const nodeDefId = "NCDRelay";
 
 type Commands = Relay.Commands;
 type Drivers = Relay.Drivers;
 
 export class RelayNode extends Base<Drivers, Commands> implements Relay.Interface {
-	public readonly commands = {
+	public override readonly commands = {
 		DON: this.on,
 		DOF: this.off,
 		QUERY: this.query,
 		ADRPST: this.adr
 	};
-	static nodeDefId = "NCDRelay";
+	static override nodeDefId = "NCDRelay";
+	static override implements = ["NCDRelay"];
 	declare readonly nodeDefId: "NCDRelay";
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
 		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
 		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
-	async on() {
-		return this.sendCommand("DON");
-	}
-	async off() {
-		return this.sendCommand("DOF");
-	}
-	async query() {
-		return this.sendCommand("QUERY");
-	}
-	async adr(value: (0 | 1)) {
-		return this.sendCommand("ADRPST", { value: value });
-	}
+	async on() { return this.sendCommand("DON"); }
+	async off() { return this.sendCommand("DOF"); }
+	async query() { return this.sendCommand("QUERY"); }
+	async adr(value: (0 | 1)) { return this.sendCommand("ADRPST", { value: value }); }
 	public get status(): (0 | 100) {
 		return this.drivers.ST?.value;
 	}
@@ -57,8 +50,9 @@ export namespace Relay {
 	export interface Interface extends Omit<InstanceType<typeof RelayNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "NCDRelay";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is RelayNode {
-		return node.nodeDefId === nodeDefId;
+	export function is(node: ISYNode<any, any, any, any>): node is RelayNode { return ["NCDRelay"].includes(node.nodeDefId); }
+	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is RelayNode {
+		return ["NCDRelay"].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new RelayNode(isy, nodeInfo);

package/src/Devices/NodeFactory.ts

@@ -4,33 +4,86 @@ import  { ISYNode } from '../ISYNode.js';
 import type { NodeDef } from '../Model/NodeDef.js';
 import { isDynamic, type NodeInfo } from '../Model/NodeInfo.js';
 import type { Constructor } from './Constructor.js';
-import type { IdentityOf } from '../Utils.js';
-import { Family } from '../Definitions/index.js';
+import type { IdentityOf, StringKeys } from '../Utils.js';
+import { Family, type EnumLiteral } from '../Definitions/index.js';
 
 
 
 export namespace NodeFactory {
 	export const registry: NodeClassRegistry = {};
 
+	export type NodeClass<T extends Family | keyof typeof Family> = T extends Family? typeof ISYNode<T, any, any, any> : T extends keyof typeof Family ? typeof ISYNode<typeof Family[T] , any, any, any> : never;
 
+	export const implementsRegistry: {[x in StringKeys<typeof Family>]?: {[x: string]: string[]}} = {};
 
+	export function register<F extends keyof typeof Family>(nodeClass: NodeClass<F>, id: string = nodeClass.nodeDefId) {
+		//let s; //FamilyNodeClassRegistry<(typeof Family)[F]>;
+		let f = Family[nodeClass.family];
+		let s = (registry[f] ?? (registry[f] = {})) as FamilyNodeClassRegistry<any>;
+		s[id] = nodeClass;
+		if (!implementsRegistry[f]) {
+			implementsRegistry[f] = {};
+		}
+		implementsRegistry[f][id] = nodeClass.implements;
+
+
+	}
 
-	export function register<F extends keyof typeof Family>(nodeClass: typeof ISYNode<(typeof Family)[F], any, any, any>, id: string = nodeClass.nodeDefId) {
-		let s: FamilyNodeClassRegistry<(typeof Family)[F]>;
 
-		s = registry[Family[nodeClass.family]] ?? (registry[nodeClass.family] = new Map());
-		s.set(nodeClass.nodeDefId, nodeClass);
+	function compare(a: typeof ISYNode<any, any, any, any>, b: typeof ISYNode<any, any, any, any>)
+	{
+		if(a.nodeDefId === b.nodeDefId)
+		{
+			return 0;
+		}
+		if(a.implements.includes(b.nodeDefId))
+			return 1;
+		if(b.implements.includes(a.nodeDefId))
+			return -1;
+		return a.nodeDefId.localeCompare(b.nodeDefId);
+	}
+
+	export function sortImplementsRegistry()
+	{
+		for (let f in implementsRegistry) {
+			let reg = implementsRegistry[f];
+			for (let e in reg) {
+
+				reg[e] = reg[e].sort((a,b) => compare(getForNodeDefId(f as keyof typeof Family, a), getForNodeDefId(f as keyof typeof Family, b)));
+			}
+		}
+	}
+
+	export function getImplements<F extends keyof typeof Family, T extends ISYNode<typeof Family[F],any,any,any>>(node: T) {
+		return implementsRegistry[Family[node.family] as F][node.nodeDefId];
 	}
 
-	export function getForNodeDefId<F extends keyof typeof Family>(family: F, nodeDefId: string): Constructor<ISYNode<(typeof Family)[F], any, any, any>> {
-		return registry[family]?.get(nodeDefId);
+	export function getForNode<F extends keyof typeof Family>(family: F, node: NodeInfo<typeof Family[F]>): NodeClass<F> {
+		if(isDynamic(node))
+		{
+			return getForNodeDefId(family, node.sgid);
+		}
+		return getForNodeDefId(family, node.nodeDefId);
 	}
 
-	export function getForNLSId<F extends keyof typeof Family>(family: F, nodeDefId: string): Constructor<ISYNode<(typeof Family)[F], any, any, any>> {
-		return registry[family].get(nodeDefId);
+
+
+	export function getForNodeDefId<F extends keyof typeof Family | Family>(family: F, nodeDefId: string): NodeClass<F> {
+		if(typeof family === "string")
+		{
+			return registry[family as keyof typeof Family][nodeDefId] as NodeClass<F>;
+		}
+		else if(typeof family === "number")
+		{
+			return registry[Family[family] as keyof typeof Family][nodeDefId] as NodeClass<F>;
+		}
+
 	}
 
-	export async function get<F extends keyof typeof Family>(node: NodeInfo<typeof Family[F]>, isy: ISY = ISY.instance): Promise<Constructor<ISYNode<typeof Family[F], any, any, any>>> {
+
+
+
+	export async function get<F extends keyof typeof Family>(node: NodeInfo<typeof Family[F]>, isy: ISY = ISY.instance): Promise<typeof ISYNode<typeof Family[F], any, any, any>> {
 		if (!isDynamic(node))
 		{
 			return Promise.resolve(getForNodeDefId(Family[node.family] as F, node.nodeDefId));
@@ -63,6 +116,7 @@ export namespace NodeFactory {
 		}
 	}
 }
-export type FamilyNodeClassRegistry<T extends Family> = Map<string, Constructor<ISYNode<T,any,any,any>>>;
+export type FamilyNodeClassRegistry<T extends Family> = {[x:string]:NodeFactory.NodeClass<T>};
+
 
-export type NodeClassRegistry = { [x in Extract<keyof typeof Family,string>]?: FamilyNodeClassRegistry<typeof Family[x]>};
+type NodeClassRegistry = { [x in Extract<keyof typeof Family,string>]?: FamilyNodeClassRegistry<typeof Family[x]>};

package/src/Devices/Poly/Generated/MatterBridge.ts

@@ -0,0 +1,84 @@
+/* THIS FILE WAS AUTOMATICALLY GENERATED. DO NOT EDIT DIRECTLY. */
+
+import { UnitOfMeasure } from "../../../Definitions/Global/UOM.js";
+import { Family } from "../../../Definitions/Global/Families.js";
+import type { NodeInfo } from "../../../Model/NodeInfo.js";
+import { ISY } from "../../../ISY.js";
+import type { ISYNode } from "../../../ISYNode.js";
+import { Base } from "../index.js";
+import { ISYDeviceNode } from "../../ISYDeviceNode.js";
+import { Driver } from "../../../Definitions/Global/Drivers.js";
+import { Poly } from "../../../Definitions/index.js";
+import type { DriverState } from "../../../Model/DriverState.js";
+import { NodeFactory } from "../../NodeFactory.js";
+
+const nodeDefId = "CONTROLLER";
+
+type Commands = MatterBridge.Commands;
+type Drivers = MatterBridge.Drivers;
+
+export class MatterBridgeNode extends Base<Drivers, Commands> implements MatterBridge.Interface {
+	public override readonly commands = {
+		DISCOVER: this.discover,
+		QUERY: this.query,
+		START_BRIDGE: this.startBridge,
+		STOP_BRIDGE: this.stopBridge
+	};
+	static override nodeDefId = "CONTROLLER";
+	static override implements = ["CONTROLLER"];
+	declare readonly nodeDefId: "CONTROLLER";
+	constructor (isy: ISY, nodeInfo: NodeInfo) {
+		super(isy, nodeInfo);
+		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Unknown, label: "Status", name: "status" });
+	}
+	async discover() { return this.sendCommand("DISCOVER"); }
+	async query() { return this.sendCommand("QUERY"); }
+	async startBridge() { return this.sendCommand("START_BRIDGE"); }
+	async stopBridge() { return this.sendCommand("STOP_BRIDGE"); }
+	public get status(): {
+        
+return this.drivers.ST?.value;
+    }
+}
+
+NodeFactory.register(MatterBridgeNode);
+
+export namespace MatterBridge {
+	export interface Interface extends Omit<InstanceType<typeof MatterBridgeNode>, keyof ISYDeviceNode<any, any, any, any>> {
+		nodeDefId: "CONTROLLER";
+	}
+	export function is(node: ISYNode<any, any, any, any>): node is MatterBridgeNode { return ["CONTROLLER"].includes(node.nodeDefId); }
+	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is MatterBridgeNode {
+		return ["CONTROLLER"].includes(node.nodeDefId);
+	}
+	export function create(isy: ISY, nodeInfo: NodeInfo) {
+		return new MatterBridgeNode(isy, nodeInfo);
+	}
+	export const Node = MatterBridgeNode;
+	export type Commands = {
+		DISCOVER: (() => Promise<boolean>) & {
+			label: "Discover";
+			name: "discover";
+		};
+		QUERY: (() => Promise<boolean>) & {
+			label: "Query";
+			name: "query";
+		};
+		START_BRIDGE: (() => Promise<boolean>) & {
+			label: "Start Bridge";
+			name: "startBridge";
+		};
+		STOP_BRIDGE: (() => Promise<boolean>) & {
+			label: "Stop Bridge";
+			name: "stopBridge";
+		};
+	};
+	export type Drivers = {
+		ST: {
+			uom: ;
+			value: ;
+			label: "Status";
+			name: "status";
+		};
+	};
+}

package/src/Devices/Scene/Generated/Scene.ts

@@ -1,24 +1,24 @@
-/* THIS FILE WAS AUTOMATICALLY GENERATED. DO NOT EDIT DIRECTLY. */
-
+/* THIS FILE WAS AUTOMATICALLY GENERATED. DO NOT EDIT DIRECTLY. */
+
 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";
 import { Driver } from "../../../Definitions/Global/Drivers.js";
-import { Scene as SceneEnums } from "../../../Definitions/index.js";
+import { Scene } from "../../../Definitions/index.js";
 import type { DriverState } from "../../../Model/DriverState.js";
 import { NodeFactory } from "../../NodeFactory.js";
-
-export const nodeDefId = "InsteonDimmer";
-
+
+const nodeDefId = "InsteonDimmer";
+
 type Commands = Scene.Commands;
 type Drivers = Scene.Drivers;
-
+
 export class SceneNode extends Base<Drivers, Commands> implements Scene.Interface {
-	public readonly commands = {
+	public override readonly commands = {
 		DON: this.on,
 		DOF: this.off,
 		DFOF: this.fastOff,
@@ -37,72 +37,40 @@ export class SceneNode extends Base<Drivers, Commands> implements Scene.Interfac
 		CLISPHD: this.heatSetpointShift,
 		CLISPCD: this.coolSetpointShift
 	};
-	static nodeDefId = "InsteonDimmer";
+	static override nodeDefId = "InsteonDimmer";
+	static override implements = ["InsteonDimmer"];
 	declare readonly nodeDefId: "InsteonDimmer";
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
 	}
-	async on(value?: number) {
-		return this.sendCommand("DON", { value: value });
-	}
-	async off() {
-		return this.sendCommand("DOF");
-	}
-	async fastOff() {
-		return this.sendCommand("DFOF");
-	}
-	async fastOn() {
-		return this.sendCommand("DFON");
-	}
-	async brighten() {
-		return this.sendCommand("BRT");
-	}
-	async dim() {
-		return this.sendCommand("DIM");
-	}
-	async fadeUp() {
-		return this.sendCommand("FDUP");
-	}
-	async fadeDown() {
-		return this.sendCommand("FDDOWN");
-	}
-	async fadeStop() {
-		return this.sendCommand("FDSTOP");
-	}
-	async beep() {
-		return this.sendCommand("BEEP");
-	}
-	async query() {
-		return this.sendCommand("QUERY");
-	}
-	async mode(value: number) {
-		return this.sendCommand("CLIMD", { value: value });
-	}
-	async fanMode(value: (0 | 1)) {
-		return this.sendCommand("CLIFS", { value: value });
-	}
-	async heatSetpoint(value: number) {
-		return this.sendCommand("CLISPH", { value: value });
-	}
-	async coolSetpoint(value: number) {
-		return this.sendCommand("CLISPC", { value: value });
-	}
-	async heatSetpointShift(value: number) {
-		return this.sendCommand("CLISPHD", { value: value });
-	}
-	async coolSetpointShift(value: number) {
-		return this.sendCommand("CLISPCD", { value: value });
-	}
+	async on(value?: number) { return this.sendCommand("DON", { value: value }); }
+	async off() { return this.sendCommand("DOF"); }
+	async fastOff() { return this.sendCommand("DFOF"); }
+	async fastOn() { return this.sendCommand("DFON"); }
+	async brighten() { return this.sendCommand("BRT"); }
+	async dim() { return this.sendCommand("DIM"); }
+	async fadeUp() { return this.sendCommand("FDUP"); }
+	async fadeDown() { return this.sendCommand("FDDOWN"); }
+	async fadeStop() { return this.sendCommand("FDSTOP"); }
+	async beep() { return this.sendCommand("BEEP"); }
+	async query() { return this.sendCommand("QUERY"); }
+	async mode(value: number) { return this.sendCommand("CLIMD", { value: value }); }
+	async fanMode(value: (0 | 1)) { return this.sendCommand("CLIFS", { value: value }); }
+	async heatSetpoint(value: number) { return this.sendCommand("CLISPH", { value: value }); }
+	async coolSetpoint(value: number) { return this.sendCommand("CLISPC", { value: value }); }
+	async heatSetpointShift(value: number) { return this.sendCommand("CLISPHD", { value: value }); }
+	async coolSetpointShift(value: number) { return this.sendCommand("CLISPCD", { value: value }); }
 }
-
+
 NodeFactory.register(SceneNode);
-
+
 export namespace Scene {
 	export interface Interface extends Omit<InstanceType<typeof SceneNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "InsteonDimmer";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is SceneNode {
-		return node.nodeDefId === nodeDefId;
+	export function is(node: ISYNode<any, any, any, any>): node is SceneNode { return ["InsteonDimmer"].includes(node.nodeDefId); }
+	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is SceneNode {
+		return ["InsteonDimmer"].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new SceneNode(isy, nodeInfo);

package/src/Devices/Scene/index.ts

@@ -1,4 +1,5 @@
 import type { Family } from '../../Definitions/Global/Families.js';
 import {ISYNode} from '../../ISYNode.js'
+import { ISYDeviceNode } from '../ISYDeviceNode.js';
 
-export class Base<D extends ISYNode.DriverSignatures,C extends ISYNode.CommandSignatures> extends ISYNode<Family.Scene,D,C> {}
+export class Base<D extends ISYNode.DriverSignatures,C extends ISYNode.CommandSignatures> extends ISYDeviceNode<Family.Scene,D,C> {}