isy-nodejs 1.0.9-alpha.1 → 1.3.24

package/src/Devices/ZWave/Generated/BasicAssociation.ts

@@ -0,0 +1,76 @@
+/* THIS FILE WAS AUTOMATICALLY GENERATED. DO NOT EDIT DIRECTLY. */
+
+import { Family } 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 { NodeFactory } from "../../NodeFactory.js";
+
+type Commands = BasicAssociation.Commands.Type;
+type Drivers = BasicAssociation.Drivers.Type;
+type Events = BasicAssociation.Events.Type;
+
+export class BasicAssociation extends Base<Drivers, Commands, Events> implements BasicAssociation.Interface {
+	public override readonly commands = {
+		QUERY: this.query
+	};
+	static override nodeDefId = "252";
+	static override implements = ['252', "259"];
+	declare readonly nodeDefId: '252';
+	constructor (isy: ISY, nodeInfo: NodeInfo<Family.ZWave>) {
+		super(isy, nodeInfo);
+	}
+	async query() { return this.sendCommand("QUERY"); }
+}
+
+NodeFactory.register(BasicAssociation);
+
+export namespace BasicAssociation {
+	export interface Interface extends Omit<InstanceType<typeof BasicAssociation>, keyof ISYDeviceNode<any, any, any, any>> {
+	}
+	export function is(node: ISYNode<any, any, any, any>): node is BasicAssociation {
+		return ['252'].includes(node.nodeDefId);
+	}
+	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is BasicAssociation {
+		return ['252', "137", "147"].includes(node.nodeDefId);
+	}
+	export function create(isy: ISY, nodeInfo: NodeInfo<Family.ZWave>) {
+		return new BasicAssociation(isy, nodeInfo);
+	}
+	export const Node = BasicAssociation;
+	export const Class = BasicAssociation;
+	export namespace Commands {
+		export type Type = {
+			QUERY: (() => Promise<boolean>) & {
+				label: "Query";
+				name: "query";
+			};
+		};
+	}
+	export enum Commands {
+		query = 'QUERY'
+	}
+	export namespace Drivers {
+		export type Type = {};
+	}
+	export enum Drivers {
+	}
+	export namespace Events {
+		export type Type = {
+			DON: {
+				label: "On";
+				name: "on";
+			};
+			DOF: {
+				label: "Off";
+				name: "off";
+			};
+		};
+	}
+	export enum Events {
+		on = 'DON',
+		off = 'DOF'
+	}
+}

package/src/Devices/ZWave/Generated/BinarySwitch.ts

@@ -0,0 +1,130 @@
+/* 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 { ZWave } from "../../../Definitions/index.js";
+import { NodeFactory } from "../../NodeFactory.js";
+
+type Commands = BinarySwitch.Commands.Type;
+type Drivers = BinarySwitch.Drivers.Type;
+type Events = BinarySwitch.Events.Type;
+
+export class BinarySwitch extends Base<Drivers, Commands, Events> implements BinarySwitch.Interface {
+	public override readonly commands = {
+		DON: this.on,
+		DOF: this.off,
+		QUERY: this.query,
+		CONFIG: this.setConfiguration,
+		WDU: this.writeChanges
+	};
+
+	static override nodeDefId = "147";
+	static override implements = ['147', "252", "259"];
+	declare readonly nodeDefId: '147';
+	constructor (isy: ISY, nodeInfo: NodeInfo<Family.ZWave>) {
+		super(isy, nodeInfo);
+		this.drivers.ST = Driver.create("ST", this, nodeInfo.state['ST'], { uom: UnitOfMeasure.OffOn, label: "Status", name: "status" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
+	}
+	async on(value?: (0 | 100)) { return this.sendCommand("DON", [value, UnitOfMeasure.OffOn]); }
+	async off() { return this.sendCommand("DOF"); }
+	async query() { return this.sendCommand("QUERY"); }
+	async setConfiguration(parameterNumber: number, parameterValue: number) { return this.sendCommand("CONFIG", { NUM: [parameterNumber, UnitOfMeasure.Raw1ByteUnsignedValue], VAL: parameterValue }); }
+	async writeChanges() { return this.sendCommand("WDU"); }
+	public get status(): (0 | 100 | 101) {
+		return this.drivers.ST?.value;
+	}
+	public get responding(): ZWave.Error {
+		return this.drivers.ERR?.value;
+	}
+}
+
+NodeFactory.register(BinarySwitch);
+
+export namespace BinarySwitch {
+	export interface Interface extends Omit<InstanceType<typeof BinarySwitch>, keyof ISYDeviceNode<any, any, any, any>> {
+	}
+	export function is(node: ISYNode<any, any, any, any>): node is BinarySwitch {
+		return ['147'].includes(node.nodeDefId);
+	}
+	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is BinarySwitch {
+		return ['147', "137"].includes(node.nodeDefId);
+	}
+	export function create(isy: ISY, nodeInfo: NodeInfo<Family.ZWave>) {
+		return new BinarySwitch(isy, nodeInfo);
+	}
+	export const Node = BinarySwitch;
+	export const Class = BinarySwitch;
+	export namespace Commands {
+		export type Type = {
+			DON: ((value?: (0 | 100)) => Promise<boolean>) & {
+				label: "On";
+				name: "on";
+			};
+			DOF: (() => Promise<boolean>) & {
+				label: "Off";
+				name: "off";
+			};
+			QUERY: (() => Promise<boolean>) & {
+				label: "Query";
+				name: "query";
+			};
+			CONFIG: ((NUM: number, VAL: number) => Promise<boolean>) & {
+				label: "Set Configuration";
+				name: "setConfiguration";
+			};
+			WDU: (() => Promise<boolean>) & {
+				label: "Write Changes";
+				name: "writeChanges";
+			};
+		};
+	}
+	export enum Commands {
+		on = 'DON',
+		off = 'DOF',
+		query = 'QUERY',
+		setConfiguration = 'CONFIG',
+		writeChanges = 'WDU'
+	}
+	export namespace Drivers {
+		export type Type = {
+			ST: {
+				uom: UnitOfMeasure.OffOn;
+				value: (0 | 100 | 101);
+				label: "Status";
+				name: "status";
+			};
+			ERR: {
+				uom: UnitOfMeasure.Index;
+				value: ZWave.Error;
+				label: "Responding";
+				name: "responding";
+			};
+		};
+	}
+	export enum Drivers {
+		status = 'ST',
+		responding = 'ERR'
+	}
+	export namespace Events {
+		export type Type = {
+			DON: {
+				label: "On";
+				name: "on";
+			};
+			DOF: {
+				label: "Off";
+				name: "off";
+			};
+		};
+	}
+	export enum Events {
+		on = 'DON',
+		off = 'DOF'
+	}
+}

package/src/Devices/ZWave/Generated/CentralSceneControlButton.ts

@@ -0,0 +1,115 @@
+/* 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 { NodeFactory } from "../../NodeFactory.js";
+
+type Commands = CentralSceneControlButton.Commands.Type;
+type Drivers = CentralSceneControlButton.Drivers.Type;
+type Events = CentralSceneControlButton.Events.Type;
+
+export class CentralSceneControlButton extends Base<Drivers, Commands, Events> implements CentralSceneControlButton.Interface {
+	public override readonly commands = {
+		QUERY: this.query
+	};
+
+	static override nodeDefId = "201";
+	static override implements = ['201'];
+	declare readonly nodeDefId: '201';
+	constructor (isy: ISY, nodeInfo: NodeInfo<Family.ZWave>) {
+		super(isy, nodeInfo);
+		this.drivers.ST = Driver.create("ST", this, nodeInfo.state['ST'], { uom: UnitOfMeasure.MostRecentOnStyleActionTakenForLampControl, label: "Status", name: "status" });
+	}
+	async query() { return this.sendCommand("QUERY"); }
+	public get status(): number {
+		return this.drivers.ST?.value;
+	}
+}
+
+NodeFactory.register(CentralSceneControlButton);
+
+export namespace CentralSceneControlButton {
+	export interface Interface extends Omit<InstanceType<typeof CentralSceneControlButton>, keyof ISYDeviceNode<any, any, any, any>> {
+	}
+	export function is(node: ISYNode<any, any, any, any>): node is CentralSceneControlButton {
+		return ['201'].includes(node.nodeDefId);
+	}
+	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is CentralSceneControlButton {
+		return ['201'].includes(node.nodeDefId);
+	}
+	export function create(isy: ISY, nodeInfo: NodeInfo<Family.ZWave>) {
+		return new CentralSceneControlButton(isy, nodeInfo);
+	}
+	export const Node = CentralSceneControlButton;
+	export const Class = CentralSceneControlButton;
+	export namespace Commands {
+		export type Type = {
+			QUERY: (() => Promise<boolean>) & {
+				label: "Query";
+				name: "query";
+			};
+		};
+	}
+	export enum Commands {
+		query = 'QUERY'
+	}
+	export namespace Drivers {
+		export type Type = {
+			ST: {
+				uom: UnitOfMeasure.MostRecentOnStyleActionTakenForLampControl;
+				value: number;
+				label: "Status";
+				name: "status";
+			};
+		};
+	}
+	export enum Drivers {
+		status = 'ST'
+	}
+	export namespace Events {
+		export type Type = {
+			DON: {
+				label: "On";
+				name: "on";
+			};
+			FDSTOP: {
+				label: "Fade Stop";
+				name: "fadeStop";
+			};
+			FDUP: {
+				label: "Fade Up";
+				name: "fadeUp";
+			};
+			DFON: {
+				label: "Fast On";
+				name: "fastOn";
+			};
+			DON3: {
+				label: "Triple Press (On)";
+				name: "triplePressOn";
+			};
+			DON4: {
+				label: "4 x Press (On)";
+				name: "4XPressOn";
+			};
+			DON5: {
+				label: "5 x Press (On)";
+				name: "5XPressOn";
+			};
+		};
+	}
+	export enum Events {
+		on = 'DON',
+		fadeStop = 'FDSTOP',
+		fadeUp = 'FDUP',
+		fastOn = 'DFON',
+		triplePressOn = 'DON3',
+		'4XPressOn' = 'DON4',
+		'5XPressOn' = 'DON5'
+	}
+}

package/src/Devices/ZWave/Generated/ColorSwitch.ts

@@ -1,23 +1,21 @@
 /* THIS FILE WAS AUTOMATICALLY GENERATED. DO NOT EDIT DIRECTLY. */
 
-import { UnitOfMeasure } from "../../../Definitions/Global/UOM.js";
-import { Family } from "../../../Definitions/Global/Families.js";
+import { Family, UnitOfMeasure } from "../../../Definitions/Global/index.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 { 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 { ZWave } from "../../../Definitions/index.js";
-import type { DriverState } from "../../../Model/DriverState.js";
 import { NodeFactory } from "../../NodeFactory.js";
 
-const nodeDefId = "186";
+type Commands = ColorSwitch.Commands.Type;
+type Drivers = ColorSwitch.Drivers.Type;
+type Events = ColorSwitch.Events.Type;
 
-type Commands = ColorSwitch.Commands;
-type Drivers = ColorSwitch.Drivers;
-
-class ColorSwitchNode extends Base<Drivers, Commands> implements ColorSwitch.Interface {
+export class ColorSwitch extends Base<Drivers, Commands, Events> implements ColorSwitch.Interface {
 	public override readonly commands = {
 		DON: this.set,
 		FDUP: this.fadeUp,
@@ -25,106 +23,131 @@ class ColorSwitchNode extends Base<Drivers, Commands> implements ColorSwitch.Int
 		FDSTOP: this.fadeStop,
 		QUERY: this.query
 	};
+
 	static override nodeDefId = "186";
 	static override implements = ['186'];
 	declare readonly nodeDefId: '186';
-	constructor (isy: ISY, nodeInfo: NodeInfo) {
+	constructor (isy: ISY, nodeInfo: NodeInfo<Family.ZWave>) {
 		super(isy, nodeInfo);
 		this.drivers.GV0 = Driver.create("GV0", this, nodeInfo.state['GV0'], { uom: UnitOfMeasure.Raw1ByteUnsignedValue, label: "Warm White", name: "warmWhite" });
+		this.drivers.GV1 = Driver.create("GV1", this, nodeInfo.state['GV1'], { uom: UnitOfMeasure.Raw1ByteUnsignedValue, label: "Cold White", name: "coldWhite" });
 		this.drivers.GV2 = Driver.create("GV2", this, nodeInfo.state['GV2'], { uom: UnitOfMeasure.Raw1ByteUnsignedValue, label: "Red", name: "red" });
 		this.drivers.GV3 = Driver.create("GV3", this, nodeInfo.state['GV3'], { uom: UnitOfMeasure.Raw1ByteUnsignedValue, label: "Green", name: "green" });
 		this.drivers.GV4 = Driver.create("GV4", this, nodeInfo.state['GV4'], { uom: UnitOfMeasure.Raw1ByteUnsignedValue, label: "Blue", name: "blue" });
-		this.drivers.GV1 = Driver.create("GV1", this, nodeInfo.state['GV1'], { uom: UnitOfMeasure.Raw1ByteUnsignedValue, label: "Cold White", name: "coldWhite" });
 	}
-	async set(warmWhite?: number, red?: number, green?: number, blue?: number, duration?: number, coldWhite?: number) { return this.sendCommand("DON", { GV0: warmWhite, GV2: red, GV3: green, GV4: blue, RR: duration, GV1: coldWhite }); }
-	async fadeUp(component: ZWave.ColorComponent, startLevel?: number, duration?: number) { return this.sendCommand("FDUP", { ID: component, STARTLEVEL: startLevel, RR: duration }); }
-	async fadeDown(component: ZWave.ColorComponent, startLevel?: number, duration?: number) { return this.sendCommand("FDDOWN", { ID: component, STARTLEVEL: startLevel, RR: duration }); }
-	async fadeStop(component: ZWave.ColorComponent) { return this.sendCommand("FDSTOP", { ID: component }); }
+	async set(warmWhite?: number, coldWhite?: number, red?: number, green?: number, blue?: number, duration?: number) { return this.sendCommand("DON", { GV0: [warmWhite, UnitOfMeasure.Raw1ByteUnsignedValue], GV1: [coldWhite, UnitOfMeasure.Raw1ByteUnsignedValue], GV2: [red, UnitOfMeasure.Raw1ByteUnsignedValue], GV3: [green, UnitOfMeasure.Raw1ByteUnsignedValue], GV4: [blue, UnitOfMeasure.Raw1ByteUnsignedValue], RR: duration }); }
+	async fadeUp(component: ZWave.ColorComponent, startLevel?: number, duration?: number) { return this.sendCommand("FDUP", { ID: [component, UnitOfMeasure.Index], STARTLEVEL: [startLevel, UnitOfMeasure.Raw1ByteUnsignedValue], RR: duration }); }
+	async fadeDown(component: ZWave.ColorComponent, startLevel?: number, duration?: number) { return this.sendCommand("FDDOWN", { ID: [component, UnitOfMeasure.Index], STARTLEVEL: [startLevel, UnitOfMeasure.Raw1ByteUnsignedValue], RR: duration }); }
+	async fadeStop(component: ZWave.ColorComponent) { return this.sendCommand("FDSTOP", { ID: [component, UnitOfMeasure.Index] }); }
 	async query() { return this.sendCommand("QUERY"); }
-	public get warmWhite(): number {
+	public get warmWhite(): IntRange<0, 255> {
 		return this.drivers.GV0?.value;
 	}
-	public get red(): number {
+	public get coldWhite(): IntRange<0, 255> {
+		return this.drivers.GV1?.value;
+	}
+	public get red(): IntRange<0, 255> {
 		return this.drivers.GV2?.value;
 	}
-	public get green(): number {
+	public get green(): IntRange<0, 255> {
 		return this.drivers.GV3?.value;
 	}
-	public get blue(): number {
+	public get blue(): IntRange<0, 255> {
 		return this.drivers.GV4?.value;
 	}
-	public get coldWhite(): number {
-		return this.drivers.GV1?.value;
-	}
 }
 
-NodeFactory.register(ColorSwitchNode);
+NodeFactory.register(ColorSwitch);
 
 export namespace ColorSwitch {
-	export interface Interface extends Omit<InstanceType<typeof ColorSwitchNode>, keyof ISYDeviceNode<any, any, any, any>> {
+	export interface Interface extends Omit<InstanceType<typeof ColorSwitch>, keyof ISYDeviceNode<any, any, any, any>> {
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is ColorSwitchNode {
+	export function is(node: ISYNode<any, any, any, any>): node is ColorSwitch {
 		return ['186'].includes(node.nodeDefId);
 	}
-	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is ColorSwitchNode {
+	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is ColorSwitch {
 		return ['186'].includes(node.nodeDefId);
 	}
-	export function create(isy: ISY, nodeInfo: NodeInfo) {
-		return new ColorSwitchNode(isy, nodeInfo);
+	export function create(isy: ISY, nodeInfo: NodeInfo<Family.ZWave>) {
+		return new ColorSwitch(isy, nodeInfo);
 	}
-	export const Node = ColorSwitchNode;
-	export type Commands = {
-		DON: ((GV0?: number, GV2?: number, GV3?: number, GV4?: number, RR?: number, GV1?: number) => Promise<boolean>) & {
-			label: "Set";
-			name: "set";
-		};
-		FDUP: ((ID: ZWave.ColorComponent, STARTLEVEL?: number, RR?: number) => Promise<boolean>) & {
-			label: "Fade Up";
-			name: "fadeUp";
-		};
-		FDDOWN: ((ID: ZWave.ColorComponent, STARTLEVEL?: number, RR?: number) => Promise<boolean>) & {
-			label: "Fade Down";
-			name: "fadeDown";
-		};
-		FDSTOP: ((ID: ZWave.ColorComponent) => Promise<boolean>) & {
-			label: "Fade Stop";
-			name: "fadeStop";
+	export const Node = ColorSwitch;
+	export const Class = ColorSwitch;
+	export namespace Commands {
+		export type Type = {
+			DON: ((GV0?: number, GV1?: number, GV2?: number, GV3?: number, GV4?: number, RR?: number) => Promise<boolean>) & {
+				label: "Set";
+				name: "set";
+			};
+			FDUP: ((ID: ZWave.ColorComponent, STARTLEVEL?: number, RR?: number) => Promise<boolean>) & {
+				label: "Fade Up";
+				name: "fadeUp";
+			};
+			FDDOWN: ((ID: ZWave.ColorComponent, STARTLEVEL?: number, RR?: number) => Promise<boolean>) & {
+				label: "Fade Down";
+				name: "fadeDown";
+			};
+			FDSTOP: ((ID: ZWave.ColorComponent) => Promise<boolean>) & {
+				label: "Fade Stop";
+				name: "fadeStop";
+			};
+			QUERY: (() => Promise<boolean>) & {
+				label: "Query";
+				name: "query";
+			};
 		};
-		QUERY: (() => Promise<boolean>) & {
-			label: "Query";
-			name: "query";
-		};
-	};
-	export type Drivers = {
-		GV0: {
-			uom: UnitOfMeasure.Raw1ByteUnsignedValue;
-			value: number;
-			label: "Warm White";
-			name: "warmWhite";
-		};
-		GV2: {
-			uom: UnitOfMeasure.Raw1ByteUnsignedValue;
-			value: number;
-			label: "Red";
-			name: "red";
-		};
-		GV3: {
-			uom: UnitOfMeasure.Raw1ByteUnsignedValue;
-			value: number;
-			label: "Green";
-			name: "green";
-		};
-		GV4: {
-			uom: UnitOfMeasure.Raw1ByteUnsignedValue;
-			value: number;
-			label: "Blue";
-			name: "blue";
-		};
-		GV1: {
-			uom: UnitOfMeasure.Raw1ByteUnsignedValue;
-			value: number;
-			label: "Cold White";
-			name: "coldWhite";
+	}
+	export enum Commands {
+		set = 'DON',
+		fadeUp = 'FDUP',
+		fadeDown = 'FDDOWN',
+		fadeStop = 'FDSTOP',
+		query = 'QUERY'
+	}
+	export namespace Drivers {
+		export type Type = {
+			GV0: {
+				uom: UnitOfMeasure.Raw1ByteUnsignedValue;
+				value: IntRange<0, 255>;
+				label: "Warm White";
+				name: "warmWhite";
+			};
+			GV1: {
+				uom: UnitOfMeasure.Raw1ByteUnsignedValue;
+				value: IntRange<0, 255>;
+				label: "Cold White";
+				name: "coldWhite";
+			};
+			GV2: {
+				uom: UnitOfMeasure.Raw1ByteUnsignedValue;
+				value: IntRange<0, 255>;
+				label: "Red";
+				name: "red";
+			};
+			GV3: {
+				uom: UnitOfMeasure.Raw1ByteUnsignedValue;
+				value: IntRange<0, 255>;
+				label: "Green";
+				name: "green";
+			};
+			GV4: {
+				uom: UnitOfMeasure.Raw1ByteUnsignedValue;
+				value: IntRange<0, 255>;
+				label: "Blue";
+				name: "blue";
+			};
 		};
-	};
+	}
+	export enum Drivers {
+		warmWhite = 'GV0',
+		coldWhite = 'GV1',
+		red = 'GV2',
+		green = 'GV3',
+		blue = 'GV4'
+	}
+	export namespace Events {
+		export type Type = {};
+	}
+	export enum Events {
+	}
 }