isy-nodejs 1.0.9-alpha.1 → 1.3.24

package/src/Devices/ZigBee/Generated/ColorXYTemperature.ts

@@ -0,0 +1,180 @@
+/* THIS FILE WAS AUTOMATICALLY GENERATED. DO NOT EDIT DIRECTLY. */
+
+import { Family, UnitOfMeasure } from "../../../Definitions/Global/index.js";
+import type { NodeInfo } from "../../../Model/NodeInfo.js";
+import { ISY } from "../../../ISY.js";
+import { ISYNode } from "../../../ISYNode.js";
+import { ISYDeviceNode } from "../../ISYDeviceNode.js";
+import { Base } from "../index.js";
+import { Driver } from "../../../Definitions/Global/Drivers.js";
+import type { IntRange } from "type-fest";
+import { ZigBee } from "../../../Definitions/index.js";
+import { NodeFactory } from "../../NodeFactory.js";
+
+type Commands = ColorXYTemperature.Commands.Type;
+type Drivers = ColorXYTemperature.Drivers.Type;
+type Events = ColorXYTemperature.Events.Type;
+
+export class ColorXYTemperature extends Base<Drivers, Commands, Events> implements ColorXYTemperature.Interface {
+	public override readonly commands = {
+		MOVETOXY: this.moveToXy,
+		MOVEXY: this.moveXy,
+		STEPXY: this.stepXy,
+		MOVETOCT: this.moveToTemperature,
+		MOVECT: this.moveTemperature,
+		STEPCT: this.stepTemperature,
+		UNITS: this.updatePreferredUnits,
+		STOP: this.stop,
+		QUERY: this.query
+	};
+	static override nodeDefId = "108";
+	static override implements = ['108'];
+	declare readonly nodeDefId: '108';
+	constructor (isy: ISY, nodeInfo: NodeInfo<Family.ZigBee>) {
+		super(isy, nodeInfo);
+		this.drivers.GV0 = Driver.create("GV0", this, nodeInfo.state['GV0'], { uom: UnitOfMeasure.ColorXY, label: "Color X", name: "colorX" });
+		this.drivers.GV1 = Driver.create("GV1", this, nodeInfo.state['GV1'], { uom: UnitOfMeasure.ColorXY, label: "Color Y", name: "colorY" });
+		this.drivers.GV2 = Driver.create("GV2", this, nodeInfo.state['GV2'], { uom: UnitOfMeasure.Kelvin, label: "Color Temperature K", name: "colorTemperatureK" });
+		this.drivers.GV3 = Driver.create("GV3", this, nodeInfo.state['GV3'], { uom: UnitOfMeasure.MiredColorTemp, label: "Color Temperature Mired", name: "colorTemperatureMired" });
+		this.drivers.GV4 = Driver.create("GV4", this, nodeInfo.state['GV4'], { uom: UnitOfMeasure.Index, label: "Preferred Units", name: "preferredUnits" });
+	}
+	async moveToXy(x: number, y: number, duration?: number) { return this.sendCommand("MOVETOXY", { X: [x, UnitOfMeasure.ColorXY], Y: [y, UnitOfMeasure.ColorXY], DUR: [duration, UnitOfMeasure.DurationInSeconds] }); }
+	async moveXy(rateX?: number, rateY?: number) { return this.sendCommand("MOVEXY", { RATEX: [rateX, UnitOfMeasure.StepsPerSecond], RATEY: [rateY, UnitOfMeasure.StepsPerSecond] }); }
+	async stepXy(stepX?: number, stepY?: number) { return this.sendCommand("STEPXY", { STEPX: [stepX, UnitOfMeasure.ColorXY], STEPY: [stepY, UnitOfMeasure.ColorXY] }); }
+	async moveToTemperature(color: number, duration?: number) { return this.sendCommand("MOVETOCT", { COLOR: [color, UnitOfMeasure.Kelvin], DUR: [duration, UnitOfMeasure.DurationInSeconds] }); }
+	async moveTemperature(mode: ZigBee.ColorControlMoveMode, min?: number, max?: number, rate?: number) { return this.sendCommand("MOVECT", { MIN: [min, UnitOfMeasure.Kelvin], MAX: [max, UnitOfMeasure.Kelvin], MODE: [mode, UnitOfMeasure.Index], RATE: [rate, UnitOfMeasure.StepsPerSecond] }); }
+	async stepTemperature(min?: number, max?: number, stepSize?: number, mode?: ZigBee.ColorControlStepMode, duration?: number) { return this.sendCommand("STEPCT", { MIN: [min, UnitOfMeasure.Kelvin], MAX: [max, UnitOfMeasure.Kelvin], SIZE: [stepSize, UnitOfMeasure.Kelvin], MODE: [mode, UnitOfMeasure.Index], DUR: [duration, UnitOfMeasure.DurationInSeconds] }); }
+	async updatePreferredUnits(value: ZigBee.ColorTemperatureUnit) { return this.sendCommand("UNITS", [value, UnitOfMeasure.Index]); }
+	async stop() { return this.sendCommand("STOP"); }
+	async query() { return this.sendCommand("QUERY"); }
+	public get colorX(): IntRange<0, 1> {
+		return this.drivers.GV0?.value;
+	}
+	public get colorY(): IntRange<0, 1> {
+		return this.drivers.GV1?.value;
+	}
+	public get colorTemperatureK(): IntRange<0, 1> {
+		return this.drivers.GV2?.value;
+	}
+	public get colorTemperatureMired(): IntRange<0, 1> {
+		return this.drivers.GV3?.value;
+	}
+	public get preferredUnits(): ZigBee.ColorTemperatureUnit {
+		return this.drivers.GV4?.value;
+	}
+}
+
+NodeFactory.register(ColorXYTemperature);
+
+export namespace ColorXYTemperature {
+	export interface Interface extends Omit<InstanceType<typeof ColorXYTemperature>, keyof ISYDeviceNode<any, any, any, any>> {
+	}
+	export function is(node: ISYNode<any, any, any, any>): node is ColorXYTemperature {
+		return ['108'].includes(node.nodeDefId);
+	}
+	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is ColorXYTemperature {
+		return ['108'].includes(node.nodeDefId);
+	}
+	export function create(isy: ISY, nodeInfo: NodeInfo<Family.ZigBee>) {
+		return new ColorXYTemperature(isy, nodeInfo);
+	}
+	export const Node = ColorXYTemperature;
+	export const Class = ColorXYTemperature;
+	export namespace Commands {
+		export type Type = {
+			MOVETOXY: ((X: number, Y: number, DUR?: number) => Promise<boolean>) & {
+				label: "Move To XY";
+				name: "moveToXy";
+			};
+			MOVEXY: ((RATEX?: number, RATEY?: number) => Promise<boolean>) & {
+				label: "Move XY";
+				name: "moveXy";
+			};
+			STEPXY: ((STEPX?: number, STEPY?: number) => Promise<boolean>) & {
+				label: "Step XY";
+				name: "stepXy";
+			};
+			MOVETOCT: ((COLOR: number, DUR?: number) => Promise<boolean>) & {
+				label: "Move To Temperature";
+				name: "moveToTemperature";
+			};
+			MOVECT: ((MODE: ZigBee.ColorControlMoveMode, MIN?: number, MAX?: number, RATE?: number) => Promise<boolean>) & {
+				label: "Move Temperature";
+				name: "moveTemperature";
+			};
+			STEPCT: ((MIN?: number, MAX?: number, SIZE?: number, MODE?: ZigBee.ColorControlStepMode, DUR?: number) => Promise<boolean>) & {
+				label: "Step Temperature";
+				name: "stepTemperature";
+			};
+			UNITS: ((value: ZigBee.ColorTemperatureUnit) => Promise<boolean>) & {
+				label: "Preferred Units";
+				name: "updatePreferredUnits";
+			};
+			STOP: (() => Promise<boolean>) & {
+				label: "Stop";
+				name: "stop";
+			};
+			QUERY: (() => Promise<boolean>) & {
+				label: "Query";
+				name: "query";
+			};
+		};
+	}
+	export enum Commands {
+		moveToXy = 'MOVETOXY',
+		moveXy = 'MOVEXY',
+		stepXy = 'STEPXY',
+		moveToTemperature = 'MOVETOCT',
+		moveTemperature = 'MOVECT',
+		stepTemperature = 'STEPCT',
+		updatePreferredUnits = 'UNITS',
+		stop = 'STOP',
+		query = 'QUERY'
+	}
+	export namespace Drivers {
+		export type Type = {
+			GV0: {
+				uom: UnitOfMeasure.ColorXY;
+				value: IntRange<0, 1>;
+				label: "Color X";
+				name: "colorX";
+			};
+			GV1: {
+				uom: UnitOfMeasure.ColorXY;
+				value: IntRange<0, 1>;
+				label: "Color Y";
+				name: "colorY";
+			};
+			GV2: {
+				uom: UnitOfMeasure.Kelvin;
+				value: IntRange<0, 1>;
+				label: "Color Temperature K";
+				name: "colorTemperatureK";
+			};
+			GV3: {
+				uom: UnitOfMeasure.MiredColorTemp;
+				value: IntRange<0, 1>;
+				label: "Color Temperature Mired";
+				name: "colorTemperatureMired";
+			};
+			GV4: {
+				uom: UnitOfMeasure.Index;
+				value: ZigBee.ColorTemperatureUnit;
+				label: "Preferred Units";
+				name: "preferredUnits";
+			};
+		};
+	}
+	export enum Drivers {
+		colorX = 'GV0',
+		colorY = 'GV1',
+		colorTemperatureK = 'GV2',
+		colorTemperatureMired = 'GV3',
+		preferredUnits = 'GV4'
+	}
+	export namespace Events {
+		export type Type = {};
+	}
+	export enum Events {
+	}
+}

package/src/Devices/ZigBee/Generated/LevelControl.ts

@@ -0,0 +1,178 @@
+/* THIS FILE WAS AUTOMATICALLY GENERATED. DO NOT EDIT DIRECTLY. */
+
+import { Family, UnitOfMeasure } from "../../../Definitions/Global/index.js";
+import type { NodeInfo } from "../../../Model/NodeInfo.js";
+import { ISY } from "../../../ISY.js";
+import { ISYNode } from "../../../ISYNode.js";
+import { ISYDeviceNode } from "../../ISYDeviceNode.js";
+import { Base } from "../index.js";
+import { Driver } from "../../../Definitions/Global/Drivers.js";
+import type { IntRange } from "type-fest";
+import { ZigBee } from "../../../Definitions/index.js";
+import { NodeFactory } from "../../NodeFactory.js";
+
+type Commands = LevelControl.Commands.Type;
+type Drivers = LevelControl.Drivers.Type;
+
+class LevelControlNode extends Base<Drivers, Commands> implements LevelControl.Interface {
+	public override readonly commands = {
+		DON: this.on,
+		DOF: this.off,
+		DFON: this.fastOn,
+		DFOF: this.fastOff,
+		TOGGLE: this.toggle,
+		BRT: this.brighten,
+		DIM: this.dim,
+		OL: this.updateOnLevel,
+		RR: this.updateRampRate,
+		IDENTIFY: this.identify,
+		QUERY: this.query
+	};
+	static override nodeDefId = "LEVEL_CONTROL";
+	static override implements = ['LEVEL_CONTROL'];
+	declare readonly nodeDefId: 'LEVEL_CONTROL' | "OnOffLevel";
+	constructor (isy: ISY, nodeInfo: NodeInfo<Family.ZigBee>) {
+		super(isy, nodeInfo);
+		this.drivers.ST = Driver.create("ST", this, nodeInfo.state['ST'], { uom: UnitOfMeasure.OffOn, label: "Status", name: "status" });
+		this.drivers.OL = Driver.create("OL", this, nodeInfo.state['OL'], { uom: UnitOfMeasure.Percent, label: "On Level", name: "onLevel" });
+		this.drivers.RR = Driver.create("RR", this, nodeInfo.state['RR'], { uom: UnitOfMeasure.DurationInSeconds, label: "Ramp Rate", name: "rampRate" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
+	}
+	async on(value?: number, rampRate?: number) { return this.sendCommand("DON", value, { RR: [rampRate, UnitOfMeasure.DurationInSeconds] }); }
+	async off() { return this.sendCommand("DOF"); }
+	async fastOn() { return this.sendCommand("DFON"); }
+	async fastOff() { return this.sendCommand("DFOF"); }
+	async toggle() { return this.sendCommand("TOGGLE"); }
+	async brighten() { return this.sendCommand("BRT"); }
+	async dim() { return this.sendCommand("DIM"); }
+	async updateOnLevel(value: number) { return this.sendCommand("OL", value); }
+	async updateRampRate(value: number) { return this.sendCommand("RR", [value, UnitOfMeasure.DurationInSeconds]); }
+	async identify(value?: number) { return this.sendCommand("IDENTIFY", [value, UnitOfMeasure.DurationInSeconds]); }
+	async query() { return this.sendCommand("QUERY"); }
+	public get status(): (0 | 100 | 101) {
+		return this.drivers.ST?.value;
+	}
+	public get onLevel(): number | IntRange<0, 255> {
+		return this.drivers.OL?.value;
+	}
+	public get rampRate(): number {
+		return this.drivers.RR?.value;
+	}
+	public get responding(): ZigBee.Error {
+		return this.drivers.ERR?.value;
+	}
+}
+
+NodeFactory.register(LevelControlNode);
+NodeFactory.register(LevelControlNode, "OnOffLevel");
+
+export namespace LevelControl {
+	export interface Interface extends Omit<InstanceType<typeof LevelControlNode>, keyof ISYDeviceNode<any, any, any, any>> {
+	}
+	export function is(node: ISYNode<any, any, any, any>): node is LevelControlNode {
+		return ['LEVEL_CONTROL', "OnOffLevel"].includes(node.nodeDefId);
+	}
+	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is LevelControlNode {
+		return ['LEVEL_CONTROL', "OnOffLevel"].includes(node.nodeDefId);
+	}
+	export function create(isy: ISY, nodeInfo: NodeInfo<Family.ZigBee>) {
+		return new LevelControlNode(isy, nodeInfo);
+	}
+	export const Node = LevelControlNode;
+	export const Class = LevelControlNode;
+	export namespace Commands {
+		export type Type = {
+			DON: ((value?: number, RR?: number) => Promise<boolean>) & {
+				label: "On";
+				name: "on";
+			};
+			DOF: (() => Promise<boolean>) & {
+				label: "Off";
+				name: "off";
+			};
+			DFON: (() => Promise<boolean>) & {
+				label: "Fast On";
+				name: "fastOn";
+			};
+			DFOF: (() => Promise<boolean>) & {
+				label: "Fast Off";
+				name: "fastOff";
+			};
+			TOGGLE: (() => Promise<boolean>) & {
+				label: "Toggle";
+				name: "toggle";
+			};
+			BRT: (() => Promise<boolean>) & {
+				label: "Brighten";
+				name: "brighten";
+			};
+			DIM: (() => Promise<boolean>) & {
+				label: "Dim";
+				name: "dim";
+			};
+			OL: ((value: number) => Promise<boolean>) & {
+				label: "On Level";
+				name: "updateOnLevel";
+			};
+			RR: ((value: number) => Promise<boolean>) & {
+				label: "Ramp Rate";
+				name: "updateRampRate";
+			};
+			IDENTIFY: ((value?: number) => Promise<boolean>) & {
+				label: "Identify";
+				name: "identify";
+			};
+			QUERY: (() => Promise<boolean>) & {
+				label: "Query";
+				name: "query";
+			};
+		};
+	}
+	export enum Commands {
+		on = 'DON',
+		off = 'DOF',
+		fastOn = 'DFON',
+		fastOff = 'DFOF',
+		toggle = 'TOGGLE',
+		brighten = 'BRT',
+		dim = 'DIM',
+		updateOnLevel = 'OL',
+		updateRampRate = 'RR',
+		identify = 'IDENTIFY',
+		query = 'QUERY'
+	}
+	export namespace Drivers {
+		export type Type = {
+			ST: {
+				uom: UnitOfMeasure.OffOn;
+				value: (0 | 100 | 101);
+				label: "Status";
+				name: "status";
+			};
+			OL: {
+				uom: UnitOfMeasure.Percent | UnitOfMeasure.LevelFrom0To255;
+				value: number | IntRange<0, 255>;
+				label: "On Level";
+				name: "onLevel";
+			};
+			RR: {
+				uom: UnitOfMeasure.DurationInSeconds;
+				value: number;
+				label: "Ramp Rate";
+				name: "rampRate";
+			};
+			ERR: {
+				uom: UnitOfMeasure.Index;
+				value: ZigBee.Error;
+				label: "Responding";
+				name: "responding";
+			};
+		};
+	}
+	export enum Drivers {
+		status = 'ST',
+		onLevel = 'OL',
+		rampRate = 'RR',
+		responding = 'ERR'
+	}
+}

package/src/Devices/ZigBee/Generated/OnOffLevel.ts

@@ -0,0 +1,184 @@
+/* THIS FILE WAS AUTOMATICALLY GENERATED. DO NOT EDIT DIRECTLY. */
+
+import { Family, UnitOfMeasure } from "../../../Definitions/Global/index.js";
+import type { NodeInfo } from "../../../Model/NodeInfo.js";
+import { ISY } from "../../../ISY.js";
+import { ISYNode } from "../../../ISYNode.js";
+import { ISYDeviceNode } from "../../ISYDeviceNode.js";
+import { Base } from "../index.js";
+import { Driver } from "../../../Definitions/Global/Drivers.js";
+import type { IntRange } from "type-fest";
+import { ZigBee } from "../../../Definitions/index.js";
+import { NodeFactory } from "../../NodeFactory.js";
+
+type Commands = OnOffLevel.Commands.Type;
+type Drivers = OnOffLevel.Drivers.Type;
+type Events = OnOffLevel.Events.Type;
+
+export class OnOffLevel extends Base<Drivers, Commands, Events> implements OnOffLevel.Interface {
+	public override readonly commands = {
+		DON: this.on,
+		DOF: this.off,
+		DFON: this.fastOn,
+		DFOF: this.fastOff,
+		TOGGLE: this.toggle,
+		BRT: this.brighten,
+		DIM: this.dim,
+		OL: this.updateOnLevel,
+		RR: this.updateRampRate,
+		IDENTIFY: this.identify,
+		QUERY: this.query
+	};
+
+	static override nodeDefId = "103";
+	static override implements = ['103'];
+	declare readonly nodeDefId: '103';
+	constructor (isy: ISY, nodeInfo: NodeInfo<Family.ZigBee>) {
+		super(isy, nodeInfo);
+		this.drivers.ST = Driver.create("ST", this, nodeInfo.state['ST'], { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
+		this.drivers.OL = Driver.create("OL", this, nodeInfo.state['OL'], { uom: UnitOfMeasure.Percent, label: "On Level", name: "onLevel" });
+		this.drivers.RR = Driver.create("RR", this, nodeInfo.state['RR'], { uom: UnitOfMeasure.DurationInSeconds, label: "Ramp Rate", name: "rampRate" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
+	}
+	async on(value?: number, rampRate?: number) { return this.sendCommand("DON", value, { RR: [rampRate, UnitOfMeasure.DurationInSeconds] }); }
+	async off() { return this.sendCommand("DOF"); }
+	async fastOn() { return this.sendCommand("DFON"); }
+	async fastOff() { return this.sendCommand("DFOF"); }
+	async toggle() { return this.sendCommand("TOGGLE"); }
+	async brighten() { return this.sendCommand("BRT"); }
+	async dim() { return this.sendCommand("DIM"); }
+	async updateOnLevel(value: number) { return this.sendCommand("OL", value); }
+	async updateRampRate(value: number) { return this.sendCommand("RR", [value, UnitOfMeasure.DurationInSeconds]); }
+	async identify(value?: number) { return this.sendCommand("IDENTIFY", [value, UnitOfMeasure.DurationInSeconds]); }
+	async query() { return this.sendCommand("QUERY"); }
+	public get status(): number {
+		return this.drivers.ST?.value;
+	}
+	public get onLevel(): number | IntRange<0, 255> {
+		return this.drivers.OL?.value;
+	}
+	public get rampRate(): number {
+		return this.drivers.RR?.value;
+	}
+	public get responding(): ZigBee.Error {
+		return this.drivers.ERR?.value;
+	}
+}
+
+NodeFactory.register(OnOffLevel);
+
+export namespace OnOffLevel {
+	export interface Interface extends Omit<InstanceType<typeof OnOffLevel>, keyof ISYDeviceNode<any, any, any, any>> {
+	}
+	export function is(node: ISYNode<any, any, any, any>): node is OnOffLevel {
+		return ['103'].includes(node.nodeDefId);
+	}
+	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is OnOffLevel {
+		return ['103'].includes(node.nodeDefId);
+	}
+	export function create(isy: ISY, nodeInfo: NodeInfo<Family.ZigBee>) {
+		return new OnOffLevel(isy, nodeInfo);
+	}
+	export const Node = OnOffLevel;
+	export const Class = OnOffLevel;
+	export namespace Commands {
+		export type Type = {
+			DON: ((value?: number, RR?: number) => Promise<boolean>) & {
+				label: "On";
+				name: "on";
+			};
+			DOF: (() => Promise<boolean>) & {
+				label: "Off";
+				name: "off";
+			};
+			DFON: (() => Promise<boolean>) & {
+				label: "Fast On";
+				name: "fastOn";
+			};
+			DFOF: (() => Promise<boolean>) & {
+				label: "Fast Off";
+				name: "fastOff";
+			};
+			TOGGLE: (() => Promise<boolean>) & {
+				label: "Toggle";
+				name: "toggle";
+			};
+			BRT: (() => Promise<boolean>) & {
+				label: "Brighten";
+				name: "brighten";
+			};
+			DIM: (() => Promise<boolean>) & {
+				label: "Dim";
+				name: "dim";
+			};
+			OL: ((value: number) => Promise<boolean>) & {
+				label: "On Level";
+				name: "updateOnLevel";
+			};
+			RR: ((value: number) => Promise<boolean>) & {
+				label: "Ramp Rate";
+				name: "updateRampRate";
+			};
+			IDENTIFY: ((value?: number) => Promise<boolean>) & {
+				label: "Identify";
+				name: "identify";
+			};
+			QUERY: (() => Promise<boolean>) & {
+				label: "Query";
+				name: "query";
+			};
+		};
+	}
+	export enum Commands {
+		on = 'DON',
+		off = 'DOF',
+		fastOn = 'DFON',
+		fastOff = 'DFOF',
+		toggle = 'TOGGLE',
+		brighten = 'BRT',
+		dim = 'DIM',
+		updateOnLevel = 'OL',
+		updateRampRate = 'RR',
+		identify = 'IDENTIFY',
+		query = 'QUERY'
+	}
+	export namespace Drivers {
+		export type Type = {
+			ST: {
+				uom: UnitOfMeasure.Percent;
+				value: number;
+				label: "Status";
+				name: "status";
+			};
+			OL: {
+				uom: UnitOfMeasure.Percent | UnitOfMeasure.LevelFrom0To255;
+				value: number | IntRange<0, 255>;
+				label: "On Level";
+				name: "onLevel";
+			};
+			RR: {
+				uom: UnitOfMeasure.DurationInSeconds;
+				value: number;
+				label: "Ramp Rate";
+				name: "rampRate";
+			};
+			ERR: {
+				uom: UnitOfMeasure.Index;
+				value: ZigBee.Error;
+				label: "Responding";
+				name: "responding";
+			};
+		};
+	}
+	export enum Drivers {
+		status = 'ST',
+		onLevel = 'OL',
+		rampRate = 'RR',
+		responding = 'ERR'
+	}
+	export namespace Events {
+		export type Type = {};
+	}
+	export enum Events {
+	}
+}

package/src/Devices/ZigBee/Generated/index.ts

@@ -0,0 +1,3 @@
+export * from './ColorHueSat.js';
+export * from './ColorXY.js';
+export * from './OnOffLevel.js';

package/src/Devices/ZigBee/OnOffLight.ts

@@ -0,0 +1,17 @@
+import { CompositeDevice, type Family } from '../../ISY.js';
+
+import 'winston';
+
+import { OnOffLevel } from './Generated/index.js';
+
+const nodes = { onOff: OnOffLevel };
+
+export class OnOffLight extends CompositeDevice.of<Family.ZigBee, typeof nodes>(nodes, { onOff: 103 }) {}
+
+export namespace OnOffLight {
+	export const Nodes = nodes;
+
+	export const Class = OnOffLight;
+
+	export const OnOff = nodes.onOff;
+}

package/src/Devices/ZigBee/ZigBeeBase.ts

@@ -1,22 +1,22 @@
-import { Family, Insteon } from '../../Definitions/Global/Families.js';
-import { ISY } from '../../ISY.js';
-import { byteToDegree, byteToPct, pctToByte } from '../../Utils.js';
-import { NodeInfo } from '../../Model/NodeInfo.js';
-import { ISYDeviceNode } from '../ISYDeviceNode.js';
-import { ISYNode } from '../../ISYNode.js';
 import 'winston';
-import type { Driver } from '../../Definitions/Global/Drivers.js';
-import type { Merge } from '@matter/general';
+import { Family } from '../../Definitions/Global/Families.js';
+import { ISYNode } from '../../ISYNode.js';
+import type { NodeDef } from '../../Model/NodeDef.js';
 import { DynamicNode } from '../DynamicNode.js';
 
 // import { InsteonNLS } from './insteonfam'
-export class ZigBeeBaseDevice<D extends ISYNode.DriverSignatures, C extends ISYNode.CommandSignatures, E extends ISYNode.EventSignatures = {}> extends DynamicNode<Family.ZWave,Merge<D,Driver.Signatures<'ST'>>,C,E > {
+export class ZigBeeBase<
+	D extends ISYNode.DriverSignatures,
+	C extends ISYNode.CommandSignatures,
+	E extends ISYNode.EventSignatures = {},
+> extends DynamicNode<Family.ZigBee, D, C, E> {
+	static override family: Family.ZigBee = Family.ZigBee;
+	public async getNodeDef(nodeDefId: string): Promise<NodeDef> {
+		let n = (
+			await this.isy.sendRequest(`zmatter/zigbee/node/${this.address}/def/get?full=true`, { trailingSlash: false })
+		).nodeDefs.nodedef;
 
-	public async getNodeDef()
-	{
-		return this.isy.sendRequest(`zmatter/zb/node/${this.address}/def/get?full=true`)
+		//this.logger(`Node is ZigBee. NodeDef: ${logStringify(n)}`);
+		return n;
 	}
-
-
-	
 }