isy-nodejs 1.0.9-alpha.1 → 1.3.24

package/src/Devices/ZWave/{ZWaveBaseDevice.ts → ZWaveBase.ts}

@@ -1,23 +1,30 @@
-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 { logStringify } from '../../ISY.js';
+import { ISYNode } from '../../ISYNode.js';
+import type { NodeDef } from '../../Model/NodeDef.js';
+import { byteToDegree, byteToPct, pctToByte } from '../../Utils.js';
 import { DynamicNode } from '../DynamicNode.js';
 
 // import { InsteonNLS } from './insteonfam'
-export class ZWaveBaseDevice<D extends ISYNode.DriverSignatures, C extends ISYNode.CommandSignatures, E extends ISYNode.EventSignatures = {}> extends DynamicNode<Family.ZWave,Merge<D,Driver.Signatures<'ST'>>,C,E > {
+export abstract class ZWaveBase<
+	D extends ISYNode.DriverSignatures,
+	C extends ISYNode.CommandSignatures,
+	E extends ISYNode.EventSignatures = {},
+> extends DynamicNode<Family.ZWave, D, C, E> {
+	static override family: Family.ZWave = Family.ZWave;
 
-	public async getNodeDef()
-	{
-		return this.isy.sendRequest(`zmatter/zwave/node/${this.address}/def/get?full=true`)
+	public async getNodeDef(nodeDefId: string): Promise<NodeDef> {
+		let n = (
+			await this.isy.sendRequest<{ nodeDefs: { nodeDef: NodeDef } }>(
+				`zmatter/zwave/node/${this.address}/def/get?full=true`,
+				{ trailingSlash: false }
+			)
+		).nodeDefs.nodeDef;
+		this.logger(`Node is ZWave. NodeDef: ${logStringify(n)}`);
+		return n;
 	}
 
-
 	public override convertFrom(value: any, uom: number): any {
 		switch (uom) {
 			case 101:
@@ -43,7 +50,4 @@ export class ZWaveBaseDevice<D extends ISYNode.DriverSignatures, C extends ISYNo
 				return nuom;
 		}
 	}
-	public async sendBeep(level: number = 100): Promise<any> {
-		return this.sendCommand
-	}
 }

package/src/Devices/ZWave/ZWaveLockDevice.ts

@@ -1,22 +1,17 @@
 import { ZWave, type Driver } from '../../Definitions/index.js';
 import { ISY } from '../../ISY.js';
 
-
-import { ZWaveBaseDevice } from './ZWaveBaseDevice.js';
 import 'winston';
+import { ZWaveBase } from './ZWaveBase.js';
 
-
-export class ZwaveLockDevice extends ZWaveBaseDevice<Driver.Signatures<'ST'>,any,any> {
-	constructor (isy: ISY, deviceNode: any
-	) {
+export class ZwaveLockDevice extends ZWaveBase<Driver.Signatures<'ST'>, any, any> {
+	constructor(isy: ISY, deviceNode: any) {
 		super(isy, deviceNode);
 	}
 	public sendLockCommand(lockState: any, resultHandler: any) {
+		this.sendNonSecureLockCommand(lockState);
 
-			this.sendNonSecureLockCommand(lockState);
-
-			this.sendSecureLockCommand(lockState);
-
+		this.sendSecureLockCommand(lockState);
 	}
 	get isLocked() {
 		return this.drivers.ST.value > 0;
@@ -29,16 +24,14 @@ export class ZwaveLockDevice extends ZWaveBaseDevice<Driver.Signatures<'ST'>,any
 	public async sendNonSecureLockCommand(lockState: any) {
 		if (lockState) {
 			return this.isy.sendNodeCommand(this, 'DON');
-		}
-		else {
+		} else {
 			return this.isy.sendNodeCommand(this, 'DOF');
 		}
 	}
 	public async sendSecureLockCommand(lockState: any) {
 		if (lockState) {
-			return this.isy.sendNodeCommand(this, 'DON', ZWave.OnOff);
-		}
-		else {
+			return this.isy.sendNodeCommand(this, 'DON', 1);
+		} else {
 			return this.isy.sendNodeCommand(this, 'DON', 0);
 		}
 	}

package/src/Devices/ZWave/index.ts

@@ -1,11 +1,6 @@
-import { Family as FamilyEnum } from '../../Definitions/index.js';
-import type { ISY } from '../../ISY.js';
-import { ISYNode } from '../../ISYNode.js';
-import type { NodeInfo } from '../../Model/NodeInfo.js';
-import { NodeFactory } from '../NodeFactory.js';
-
-
-export class Base<Drivers extends ISYNode.DriverSignatures, Commands extends ISYNode.CommandSignatures> extends ISYNode<FamilyEnum.ZWave, Drivers, Commands> {
+export { ZWaveBase as Base } from './ZWaveBase.js';
+export * from './Generated/index.js';
+/*export class Base<Drivers extends ISYNode.DriverSignatures, Commands extends ISYNode.CommandSignatures> extends ISYNode<FamilyEnum.ZWave, Drivers, Commands> {
 	constructor(isy: ISY, nodeInfo: NodeInfo) {
 
 		super(isy, nodeInfo);
@@ -18,11 +13,9 @@ export class Base<Drivers extends ISYNode.DriverSignatures, Commands extends ISY
 	}
 
 		//// this.productName = InsteonNLS.getDeviceDescription(String.fromCharCode(category,device,version))
-}
-
-
+}*/
 
-export async function create(...nodeInfo: NodeInfo<FamilyEnum.ZWave>[])
+/*export async function create(...nodeInfo: NodeInfo<FamilyEnum.ZWave>[])
 {
 	let nodes = [] as Base<any, any>[];
 
@@ -31,6 +24,6 @@ export async function create(...nodeInfo: NodeInfo<FamilyEnum.ZWave>[])
 		nodes.push(await NodeFactory.create(node) as unknown as Base<any, any>);
 	}
 	return nodes;
-}
+}*/
 
-//export * from './Generated/index.js';
+//export * from './Generated/index.js';

package/src/Devices/ZigBee/ColorTemperatureLight.ts

@@ -0,0 +1,25 @@
+import { type Family, CompositeDevice } from '../../ISY.js';
+
+import 'winston';
+
+import { ColorHueSat, ColorXY, OnOffLevel } from './Generated/index.js';
+
+const nodes = { onOff: OnOffLevel, colorHS: ColorHueSat, colorTemp: ColorXY };
+
+export class ColorTemperatureLight extends CompositeDevice.of<Family.ZigBee, typeof nodes>(nodes, {
+	onOff: 103,
+	colorHS: 106,
+	colorTemp: 108,
+}) {}
+
+export namespace ColorTemperatureLight {
+	export const Nodes = nodes;
+
+	export const Class = ColorTemperatureLight;
+
+	export const OnOff = nodes.onOff;
+
+	export const ColorHS = nodes.colorHS;
+
+	export const ColorXY = nodes.colorTemp;
+}

package/src/Devices/ZigBee/DimmableLight.ts

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

package/src/Devices/ZigBee/ExtendedColorLight.ts

@@ -0,0 +1,51 @@
+import { CompositeDevice, type Family, type ISY } from '../../ISY.js';
+import type { NodeInfo } from '../../Model/NodeInfo.js';
+
+import 'winston';
+
+import type { LevelControl } from '@matter/main/clusters';
+import type { ColorControl } from '@matter/types/clusters/color-control';
+import type { OnOff } from '@matter/types/clusters/on-off';
+
+import { ColorHueSat } from './Generated/ColorHueSat.js';
+import { ColorXY } from './Generated/ColorXY.js';
+import { OnOffLevel } from './Generated/OnOffLevel.js';
+import type { ZigBeeClusterData, ZigBeeClusterDataMap } from './ZigbeeClusterData.js';
+
+const nodes = { onOff: OnOffLevel, colorHS: ColorHueSat, colorXY: ColorXY };
+
+export class ExtendedColorLight extends CompositeDevice.of<Family.ZigBee, typeof nodes>(nodes, {
+	onOff: 103,
+	colorHS: 106,
+	colorXY: 108,
+}) {
+	constructor(isy: ISY, node: NodeInfo<Family.ZigBee>, clusterData: ZigBeeClusterDataMap) {
+		super(isy, node);
+		this.applyClusterData(clusterData as any);
+	}
+
+	ZigBeeClusterData: {
+		// @ts-ignore
+		COLOR_CONTROL: ZigBeeClusterData<ColorControl.Cluster>;
+		// @ts-ignore
+		ON_OFF_SWITCH: ZigBeeClusterData<OnOff.Cluster>;
+		// @ts-ignore
+		LEVEL_CONTROL: ZigBeeClusterData<LevelControl.Cluster>;
+	};
+	//@ts-ignore
+	applyClusterData(clusterData: typeof this.ZigBeeClusterData) {
+		this.ZigBeeClusterData = clusterData;
+	}
+}
+
+export namespace ExtendedColorLight {
+	export const Nodes = nodes;
+
+	export const Class = ExtendedColorLight;
+
+	export const OnOff = nodes.onOff;
+
+	export const ColorHS = nodes.colorHS;
+
+	export const ColorXY = nodes.colorXY;
+}

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

@@ -0,0 +1,165 @@
+/* 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 = ColorHueSat.Commands.Type;
+type Drivers = ColorHueSat.Drivers.Type;
+type Events = ColorHueSat.Events.Type;
+
+export class ColorHueSat extends Base<Drivers, Commands, Events> implements ColorHueSat.Interface {
+	public override readonly commands = {
+		MOVETO: this.moveTo,
+		MOVETOHUE: this.moveToHue,
+		MOVETOSAT: this.moveToSaturation,
+		MOVEHUE: this.moveHue,
+		MOVESAT: this.moveSaturation,
+		STEPHUE: this.stepHue,
+		STEPSAT: this.stepSaturation,
+		STOP: this.stop,
+		EHUE: this.updateEnhancedHue,
+		QUERY: this.query
+	};
+	static override nodeDefId = "106";
+	static override implements = ['106'];
+	declare readonly nodeDefId: '106';
+	constructor (isy: ISY, nodeInfo: NodeInfo<Family.ZigBee>) {
+		super(isy, nodeInfo);
+		this.drivers.ST = Driver.create("ST", this, nodeInfo.state['ST'], { uom: UnitOfMeasure.RawValue, label: "Hue", name: "hue" });
+		this.drivers.GV1 = Driver.create("GV1", this, nodeInfo.state['GV1'], { uom: UnitOfMeasure.RawValue, label: "Saturation", name: "saturation" });
+		this.drivers.GV2 = Driver.create("GV2", this, nodeInfo.state['GV2'], { uom: UnitOfMeasure.OffOn, label: "Enhanced Hue", name: "enhancedHue" });
+	}
+	async moveTo(hue: number, saturation: number, duration?: number) { return this.sendCommand("MOVETO", { HUE: [hue, UnitOfMeasure.DegreeOfHue0To360], SAT: [saturation, UnitOfMeasure.Percent], DUR: [duration, UnitOfMeasure.DurationInSeconds] }); }
+	async moveToHue(hue: number, direction?: ZigBee.ColorControlDirection, duration?: number) { return this.sendCommand("MOVETOHUE", { HUE: [hue, UnitOfMeasure.DegreeOfHue0To360], DIR: [direction, UnitOfMeasure.Index], DUR: [duration, UnitOfMeasure.DurationInSeconds] }); }
+	async moveToSaturation(saturation: number, duration?: number) { return this.sendCommand("MOVETOSAT", { SAT: [saturation, UnitOfMeasure.Percent], DUR: [duration, UnitOfMeasure.DurationInSeconds] }); }
+	async moveHue(mode: ZigBee.ColorControlMoveMode, rate?: number) { return this.sendCommand("MOVEHUE", { MODE: [mode, UnitOfMeasure.Index], RATE: [rate, UnitOfMeasure.RawValue] }); }
+	async moveSaturation(mode: ZigBee.ColorControlMoveMode, rate?: number) { return this.sendCommand("MOVESAT", { MODE: [mode, UnitOfMeasure.Index], RATE: [rate, UnitOfMeasure.RawValue] }); }
+	async stepHue(mode: ZigBee.ColorControlStepMode, stepSize?: number, duration?: number) { return this.sendCommand("STEPHUE", { MODE: [mode, UnitOfMeasure.Index], SIZE: [stepSize, UnitOfMeasure.DegreeOfHue0To360], DUR: [duration, UnitOfMeasure.DurationInSeconds] }); }
+	async stepSaturation(mode: ZigBee.ColorControlStepMode, stepSize?: number, duration?: number) { return this.sendCommand("STEPSAT", { MODE: [mode, UnitOfMeasure.Index], SIZE: [stepSize, UnitOfMeasure.Percent], DUR: [duration, UnitOfMeasure.DurationInSeconds] }); }
+	async stop() { return this.sendCommand("STOP"); }
+	async updateEnhancedHue(value: (0 | 100)) { return this.sendCommand("EHUE", [value, UnitOfMeasure.OffOn]); }
+	async query() { return this.sendCommand("QUERY"); }
+	public get hue(): number {
+		return this.drivers.ST?.value;
+	}
+	public get saturation(): IntRange<0, 1> {
+		return this.drivers.GV1?.value;
+	}
+	public get enhancedHue(): (0 | 100) {
+		return this.drivers.GV2?.value;
+	}
+}
+
+NodeFactory.register(ColorHueSat);
+
+export namespace ColorHueSat {
+	export interface Interface extends Omit<InstanceType<typeof ColorHueSat>, keyof ISYDeviceNode<any, any, any, any>> {
+	}
+	export function is(node: ISYNode<any, any, any, any>): node is ColorHueSat {
+		return ['106'].includes(node.nodeDefId);
+	}
+	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is ColorHueSat {
+		return ['106'].includes(node.nodeDefId);
+	}
+	export function create(isy: ISY, nodeInfo: NodeInfo<Family.ZigBee>) {
+		return new ColorHueSat(isy, nodeInfo);
+	}
+	export const Node = ColorHueSat;
+	export const Class = ColorHueSat;
+	export namespace Commands {
+		export type Type = {
+			MOVETO: ((HUE: number, SAT: number, DUR?: number) => Promise<boolean>) & {
+				label: "Move To";
+				name: "moveTo";
+			};
+			MOVETOHUE: ((HUE: number, DIR?: ZigBee.ColorControlDirection, DUR?: number) => Promise<boolean>) & {
+				label: "Move To Hue";
+				name: "moveToHue";
+			};
+			MOVETOSAT: ((SAT: number, DUR?: number) => Promise<boolean>) & {
+				label: "Move To Saturation";
+				name: "moveToSaturation";
+			};
+			MOVEHUE: ((MODE: ZigBee.ColorControlMoveMode, RATE?: number) => Promise<boolean>) & {
+				label: "Move Hue";
+				name: "moveHue";
+			};
+			MOVESAT: ((MODE: ZigBee.ColorControlMoveMode, RATE?: number) => Promise<boolean>) & {
+				label: "Move Saturation";
+				name: "moveSaturation";
+			};
+			STEPHUE: ((MODE: ZigBee.ColorControlStepMode, SIZE?: number, DUR?: number) => Promise<boolean>) & {
+				label: "Step Hue";
+				name: "stepHue";
+			};
+			STEPSAT: ((MODE: ZigBee.ColorControlStepMode, SIZE?: number, DUR?: number) => Promise<boolean>) & {
+				label: "Step Saturation";
+				name: "stepSaturation";
+			};
+			STOP: (() => Promise<boolean>) & {
+				label: "Stop";
+				name: "stop";
+			};
+			EHUE: ((value: (0 | 100)) => Promise<boolean>) & {
+				label: "Enhanced Hue";
+				name: "updateEnhancedHue";
+			};
+			QUERY: (() => Promise<boolean>) & {
+				label: "Query";
+				name: "query";
+			};
+		};
+	}
+	export enum Commands {
+		moveTo = 'MOVETO',
+		moveToHue = 'MOVETOHUE',
+		moveToSaturation = 'MOVETOSAT',
+		moveHue = 'MOVEHUE',
+		moveSaturation = 'MOVESAT',
+		stepHue = 'STEPHUE',
+		stepSaturation = 'STEPSAT',
+		stop = 'STOP',
+		updateEnhancedHue = 'EHUE',
+		query = 'QUERY'
+	}
+	export namespace Drivers {
+		export type Type = {
+			ST: {
+				uom: UnitOfMeasure.RawValue;
+				value: number;
+				label: "Hue";
+				name: "hue";
+			};
+			GV1: {
+				uom: UnitOfMeasure.RawValue;
+				value: IntRange<0, 1>;
+				label: "Saturation";
+				name: "saturation";
+			};
+			GV2: {
+				uom: UnitOfMeasure.OffOn;
+				value: (0 | 100);
+				label: "Enhanced Hue";
+				name: "enhancedHue";
+			};
+		};
+	}
+	export enum Drivers {
+		hue = 'ST',
+		saturation = 'GV1',
+		enhancedHue = 'GV2'
+	}
+	export namespace Events {
+		export type Type = {};
+	}
+	export enum Events {
+	}
+}

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

@@ -0,0 +1,174 @@
+/* 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 = ColorXY.Commands.Type;
+type Drivers = ColorXY.Drivers.Type;
+
+export class ColorXY extends Base<Drivers, Commands> implements ColorXY.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(ColorXY);
+
+export namespace ColorXY {
+	export interface Interface extends Omit<InstanceType<typeof ColorXY>, keyof ISYDeviceNode<any, any, any, any>> {
+	}
+	export function is(node: ISYNode<any, any, any, any>): node is ColorXY {
+		return ['108'].includes(node.nodeDefId);
+	}
+	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is ColorXY {
+		return ['108'].includes(node.nodeDefId);
+	}
+	export function create(isy: ISY, nodeInfo: NodeInfo<Family.ZigBee>) {
+		return new ColorXY(isy, nodeInfo);
+	}
+	export const Node = ColorXY;
+	export const Class = ColorXY;
+	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'
+	}
+}