isy-nodejs 0.5.0-beta.9 → 1.0.1-alpha.0

package/src/Devices/Lutron/Generated/LoadShed.ts

@@ -0,0 +1,91 @@
+/* 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 { Lutron } from "../../../Definitions/index.js";
+import type { DriverState } from "../../../Model/DriverState.js";
+import { NodeFactory } from "../../NodeFactory.js";
+
+export const nodeDefId = "LUTLoadShed";
+
+type Commands = LoadShed.Commands;
+type Drivers = LoadShed.Drivers;
+
+export class LoadShedNode extends Base<Drivers, Commands> implements LoadShed.Interface {
+	public readonly commands = {
+		DON: this.on,
+		DOF: this.off,
+		QUERY: this.query
+	};
+	static nodeDefId = "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");
+	}
+	public get status(): (0 | 100) {
+		return this.drivers.ST?.value;
+	}
+	public get responding(): Lutron.Error {
+		return this.drivers.ERR?.value;
+	}
+}
+
+NodeFactory.register(LoadShedNode);
+
+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 create(isy: ISY, nodeInfo: NodeInfo) {
+		return new LoadShedNode(isy, nodeInfo);
+	}
+	export const Node = LoadShedNode;
+	export type Commands = {
+		DON: ((value?: (0 | 100)) => Promise<boolean>) & {
+			label: "On";
+			name: "on";
+		};
+		DOF: (() => Promise<boolean>) & {
+			label: "Off";
+			name: "off";
+		};
+		QUERY: (() => Promise<boolean>) & {
+			label: "Query";
+			name: "query";
+		};
+	};
+	export type Drivers = {
+		ST: {
+			uom: UnitOfMeasure.Percent;
+			value: (0 | 100);
+			label: "Status";
+			name: "status";
+		};
+		ERR: {
+			uom: UnitOfMeasure.Index;
+			value: Lutron.Error;
+			label: "Responding";
+			name: "responding";
+		};
+	};
+}

package/src/Devices/Lutron/index.ts

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

package/src/Devices/MapsTo.ts

@@ -0,0 +1,28 @@
+import { Behavior } from '@project-chip/matter.js/behavior';
+import { EndpointFor, type EndpointForCluster } from './EndpointFor.js';
+import type { Cluster, ClusterType, MutableCluster } from '@project-chip/matter.js/cluster';
+
+
+export type RelaxTypes<V> = V extends number
+        ? number
+        : V extends bigint
+          ? bigint
+          : V extends object
+            ? V extends (...args: any[]) => any
+                ? V
+                : {
+                      [K in keyof V]: RelaxTypes<V[K]>;
+                  }
+            : V;
+
+
+
+export interface MapsTo<T extends Behavior.Type, T1 extends Behavior.Type = T, T2 extends Behavior.Type = T, T3 extends Behavior.Type = T> {
+	 initialize(endpoint: EndpointFor<T, T1, T2, T3>): void | Promise<void>;
+
+}
+
+export interface MapsToCluster<T extends ClusterType.Of<ClusterType.Options<{}>>, T1 extends ClusterType = T, T2 extends ClusterType = T, T3 extends ClusterType = T> {
+	initialize(endpoint: EndpointForCluster<T,T1, T2, T3>): void;
+
+}

package/src/Devices/NCD/Generated/LampAndSwitch.ts

@@ -0,0 +1,99 @@
+/* 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 { NCD } from "../../../Definitions/index.js";
+import type { DriverState } from "../../../Model/DriverState.js";
+import { NodeFactory } from "../../NodeFactory.js";
+
+export const nodeDefId = "NCDRelay";
+
+type Commands = LampAndSwitch.Commands;
+type Drivers = LampAndSwitch.Drivers;
+
+export class LampAndSwitchNode extends Base<Drivers, Commands> implements LampAndSwitch.Interface {
+	public readonly commands = {
+		DON: this.on,
+		DOF: this.off,
+		QUERY: this.query,
+		ADRPST: this.adr
+	};
+	static nodeDefId = "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 });
+	}
+	public get status(): (0 | 100) {
+		return this.drivers.ST?.value;
+	}
+	public get responding(): NCD.Error {
+		return this.drivers.ERR?.value;
+	}
+}
+
+NodeFactory.register(LampAndSwitchNode);
+
+export namespace LampAndSwitch {
+	export interface Interface extends Omit<InstanceType<typeof LampAndSwitchNode>, keyof ISYDeviceNode<any, any, any, any>> {
+		nodeDefId: "NCDRelay";
+	}
+	export function is(node: ISYNode<any, any, any, any>): node is LampAndSwitchNode {
+		return node.nodeDefId === nodeDefId;
+	}
+	export function create(isy: ISY, nodeInfo: NodeInfo) {
+		return new LampAndSwitchNode(isy, nodeInfo);
+	}
+	export const Node = LampAndSwitchNode;
+	export type Commands = {
+		DON: (() => Promise<boolean>) & {
+			label: "On";
+			name: "on";
+		};
+		DOF: (() => Promise<boolean>) & {
+			label: "Off";
+			name: "off";
+		};
+		QUERY: (() => Promise<boolean>) & {
+			label: "Query";
+			name: "query";
+		};
+		ADRPST: ((value: (0 | 1)) => Promise<boolean>) & {
+			label: "ADR";
+			name: "adr";
+		};
+	};
+	export type Drivers = {
+		ST: {
+			uom: UnitOfMeasure.Percent;
+			value: (0 | 100);
+			label: "Status";
+			name: "status";
+		};
+		ERR: {
+			uom: UnitOfMeasure.Index;
+			value: NCD.Error;
+			label: "Responding";
+			name: "responding";
+		};
+	};
+}

package/src/Devices/NCD/Generated/Relay.ts

@@ -0,0 +1,99 @@
+/* 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 { NCD } from "../../../Definitions/index.js";
+import type { DriverState } from "../../../Model/DriverState.js";
+import { NodeFactory } from "../../NodeFactory.js";
+
+export const nodeDefId = "NCDRelay";
+
+type Commands = Relay.Commands;
+type Drivers = Relay.Drivers;
+
+export class RelayNode extends Base<Drivers, Commands> implements Relay.Interface {
+	public readonly commands = {
+		DON: this.on,
+		DOF: this.off,
+		QUERY: this.query,
+		ADRPST: this.adr
+	};
+	static nodeDefId = "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 });
+	}
+	public get status(): (0 | 100) {
+		return this.drivers.ST?.value;
+	}
+	public get responding(): NCD.Error {
+		return this.drivers.ERR?.value;
+	}
+}
+
+NodeFactory.register(RelayNode);
+
+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 create(isy: ISY, nodeInfo: NodeInfo) {
+		return new RelayNode(isy, nodeInfo);
+	}
+	export const Node = RelayNode;
+	export type Commands = {
+		DON: (() => Promise<boolean>) & {
+			label: "On";
+			name: "on";
+		};
+		DOF: (() => Promise<boolean>) & {
+			label: "Off";
+			name: "off";
+		};
+		QUERY: (() => Promise<boolean>) & {
+			label: "Query";
+			name: "query";
+		};
+		ADRPST: ((value: (0 | 1)) => Promise<boolean>) & {
+			label: "ADR";
+			name: "adr";
+		};
+	};
+	export type Drivers = {
+		ST: {
+			uom: UnitOfMeasure.Percent;
+			value: (0 | 100);
+			label: "Status";
+			name: "status";
+		};
+		ERR: {
+			uom: UnitOfMeasure.Index;
+			value: NCD.Error;
+			label: "Responding";
+			name: "responding";
+		};
+	};
+}

package/src/Devices/NCD/index.ts

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

package/src/Devices/NodeFactory.ts

@@ -0,0 +1,67 @@
+import type { MaybePromise } from '@project-chip/matter.js/util';
+import { Family, ISY } from '../ISY.js';
+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';
+
+
+
+export namespace NodeFactory {
+	export const registry: NodeClassRegistry = {};
+
+
+
+
+	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);
+	}
+
+	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 getForNLSId<F extends keyof typeof Family>(family: F, nodeDefId: string): Constructor<ISYNode<(typeof Family)[F], any, any, any>> {
+		return registry[family].get(nodeDefId);
+	}
+
+	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>>> {
+		if (!isDynamic(node))
+		{
+			return Promise.resolve(getForNodeDefId(Family[node.family] as F, node.nodeDefId));
+		}
+
+		else {
+			var nd = getForNodeDefId(Family[node.family] as F, node.sgid);
+			if (nd) {
+				return Promise.resolve(nd);
+			}
+			let n = (await isy.sendRequest(
+				`zmatter/${node.family == Family.ZWave ? "zwave" : "zb"}/node/${node.address}/def/get?full=true`
+			)) as NodeDef;
+			let cls = ISYNode;
+		    NodeFactory.register(cls,n.nls);
+			return cls;
+
+
+		}
+	}
+
+
+
+	export async function create<F extends Family>(nodeInfo: NodeInfo<F>, isy: ISY = ISY.instance): Promise<ISYNode<F, any, any, any>> {
+		const nodeClass = await get(nodeInfo) as unknown as Constructor<ISYNode<F, any, any, any>>;
+		if (nodeClass.name !== "ISYNode") {
+			return new nodeClass(isy, nodeInfo);
+		} else {
+			throw new Error(`No class found for ${nodeInfo.family}.${nodeInfo.nodeDefId}`);
+		}
+	}
+}
+export type FamilyNodeClassRegistry<T extends Family> = Map<string, Constructor<ISYNode<T,any,any,any>>>;
+
+export type NodeClassRegistry = { [x in Extract<keyof typeof Family,string>]?: FamilyNodeClassRegistry<typeof Family[x]>};

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

@@ -0,0 +1,75 @@
+/* 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 { Poly } from "../../../Definitions/index.js";
+import type { DriverState } from "../../../Model/DriverState.js";
+import { NodeFactory } from "../../NodeFactory.js";
+
+export const nodeDefId = "BRIDGE";
+
+type Commands = BondBridge.Commands;
+type Drivers = BondBridge.Drivers;
+
+export class BondBridgeNode extends Base<Drivers, Commands> implements BondBridge.Interface {
+	public readonly commands = {
+		UPDATE: this.forceUpdate
+	};
+	static nodeDefId = "BRIDGE";
+	declare readonly nodeDefId: "BRIDGE";
+	constructor (isy: ISY, nodeInfo: NodeInfo) {
+		super(isy, nodeInfo);
+		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Connected", name: "connected" });
+		this.drivers.GPV = Driver.create("GPV", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Plugin Status", name: "pluginStatus" });
+	}
+	async forceUpdate() {
+		return this.sendCommand("UPDATE");
+	}
+	public get connected(): Poly.BridgeQuery {
+		return this.drivers.ST?.value;
+	}
+	public get pluginStatus(): Poly.NsStatus {
+		return this.drivers.GPV?.value;
+	}
+}
+
+NodeFactory.register(BondBridgeNode);
+
+export namespace BondBridge {
+	export interface Interface extends Omit<InstanceType<typeof BondBridgeNode>, keyof ISYDeviceNode<any, any, any, any>> {
+		nodeDefId: "BRIDGE";
+	}
+	export function is(node: ISYNode<any, any, any, any>): node is BondBridgeNode {
+		return node.nodeDefId === nodeDefId;
+	}
+	export function create(isy: ISY, nodeInfo: NodeInfo) {
+		return new BondBridgeNode(isy, nodeInfo);
+	}
+	export const Node = BondBridgeNode;
+	export type Commands = {
+		UPDATE: (() => Promise<boolean>) & {
+			label: "Force Update";
+			name: "forceUpdate";
+		};
+	};
+	export type Drivers = {
+		ST: {
+			uom: UnitOfMeasure.Index;
+			value: Poly.BridgeQuery;
+			label: "Connected";
+			name: "connected";
+		};
+		GPV: {
+			uom: UnitOfMeasure.Index;
+			value: Poly.NsStatus;
+			label: "Plugin Status";
+			name: "pluginStatus";
+		};
+	};
+}

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

@@ -0,0 +1,141 @@
+/* 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 { Poly } from "../../../Definitions/index.js";
+import type { DriverState } from "../../../Model/DriverState.js";
+import { NodeFactory } from "../../NodeFactory.js";
+
+export const nodeDefId = "CEILING_FAN";
+
+type Commands = CeilingFan.Commands;
+type Drivers = CeilingFan.Drivers;
+
+export class CeilingFanNode extends Base<Drivers, Commands> implements CeilingFan.Interface {
+	public readonly commands = {
+		DON: this.on,
+		DOF: this.off,
+		BRT: this.increaseSpeed,
+		DIM: this.decreaseSpeed,
+		INC_SPEED: this.increaseSpeed,
+		DEC_SPEED: this.decreaseSpeed,
+		SET_SPEED: this.setSpeed,
+		SET_DIRECTION: this.setDirection
+	};
+	static nodeDefId = "CEILING_FAN";
+	declare readonly nodeDefId: "CEILING_FAN";
+	constructor (isy: ISY, nodeInfo: NodeInfo) {
+		super(isy, nodeInfo);
+		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: "Fan Speed (%)", name: "fanSpeed" });
+		this.drivers.GV0 = Driver.create("GV0", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Fan Direction", name: "fanDirection" });
+		this.drivers.GV1 = Driver.create("GV1", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.RawValue, label: "Fan Speed (#)", name: "fanSpeed" });
+	}
+	async on(value?: Poly.ConfigurationQuery) {
+		return this.sendCommand("DON", { value: value });
+	}
+	async off() {
+		return this.sendCommand("DOF");
+	}
+	async increaseSpeed() {
+		return this.sendCommand("BRT");
+	}
+	async decreaseSpeed() {
+		return this.sendCommand("DIM");
+	}
+	async increaseSpeed() {
+		return this.sendCommand("INC_SPEED");
+	}
+	async decreaseSpeed() {
+		return this.sendCommand("DEC_SPEED");
+	}
+	async setSpeed(fanSpeed: number) {
+		return this.sendCommand("SET_SPEED", { FAN_SPEED: fanSpeed });
+	}
+	async setDirection(value: number) {
+		return this.sendCommand("SET_DIRECTION", { value: value });
+	}
+	public get fanSpeed(): Poly.ConfigurationQuery {
+		return this.drivers.ST?.value;
+	}
+	public get fanDirection(): number {
+		return this.drivers.GV0?.value;
+	}
+	public get fanSpeed(): number {
+		return this.drivers.GV1?.value;
+	}
+}
+
+NodeFactory.register(CeilingFanNode);
+
+export namespace CeilingFan {
+	export interface Interface extends Omit<InstanceType<typeof CeilingFanNode>, keyof ISYDeviceNode<any, any, any, any>> {
+		nodeDefId: "CEILING_FAN";
+	}
+	export function is(node: ISYNode<any, any, any, any>): node is CeilingFanNode {
+		return node.nodeDefId === nodeDefId;
+	}
+	export function create(isy: ISY, nodeInfo: NodeInfo) {
+		return new CeilingFanNode(isy, nodeInfo);
+	}
+	export const Node = CeilingFanNode;
+	export type Commands = {
+		DON: ((value?: Poly.ConfigurationQuery) => Promise<boolean>) & {
+			label: "On";
+			name: "on";
+		};
+		DOF: (() => Promise<boolean>) & {
+			label: "Off";
+			name: "off";
+		};
+		BRT: (() => Promise<boolean>) & {
+			label: "Increase Speed (%)";
+			name: "increaseSpeed";
+		};
+		DIM: (() => Promise<boolean>) & {
+			label: "Decrease Speed (%)";
+			name: "decreaseSpeed";
+		};
+		INC_SPEED: (() => Promise<boolean>) & {
+			label: "Increase Speed (#)";
+			name: "increaseSpeed";
+		};
+		DEC_SPEED: (() => Promise<boolean>) & {
+			label: "Decrease Speed (#)";
+			name: "decreaseSpeed";
+		};
+		SET_SPEED: ((FAN_SPEED: number) => Promise<boolean>) & {
+			label: "Set Speed";
+			name: "setSpeed";
+		};
+		SET_DIRECTION: ((value: number) => Promise<boolean>) & {
+			label: "Set Direction";
+			name: "setDirection";
+		};
+	};
+	export type Drivers = {
+		ST: {
+			uom: UnitOfMeasure.Percent;
+			value: Poly.ConfigurationQuery;
+			label: "Fan Speed (%)";
+			name: "fanSpeed";
+		};
+		GV0: {
+			uom: UnitOfMeasure.Index;
+			value: number;
+			label: "Fan Direction";
+			name: "fanDirection";
+		};
+		GV1: {
+			uom: UnitOfMeasure.RawValue;
+			value: number;
+			label: "Fan Speed (#)";
+			name: "fanSpeed";
+		};
+	};
+}

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

@@ -0,0 +1,73 @@
+/* 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 { Poly } from "../../../Definitions/index.js";
+import type { DriverState } from "../../../Model/DriverState.js";
+import { NodeFactory } from "../../NodeFactory.js";
+
+export const nodeDefId = "FIREPLACE";
+
+type Commands = Fireplace.Commands;
+type Drivers = Fireplace.Drivers;
+
+export class FireplaceNode extends Base<Drivers, Commands> implements Fireplace.Interface {
+	public readonly commands = {
+		DON: this.on,
+		DOF: this.off
+	};
+	static nodeDefId = "FIREPLACE";
+	declare readonly nodeDefId: "FIREPLACE";
+	constructor (isy: ISY, nodeInfo: NodeInfo) {
+		super(isy, nodeInfo);
+		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.OffOn, label: "Status", name: "status" });
+	}
+	async on() {
+		return this.sendCommand("DON");
+	}
+	async off() {
+		return this.sendCommand("DOF");
+	}
+	public get status(): (0 | 100 | 101) {
+		return this.drivers.ST?.value;
+	}
+}
+
+NodeFactory.register(FireplaceNode);
+
+export namespace Fireplace {
+	export interface Interface extends Omit<InstanceType<typeof FireplaceNode>, keyof ISYDeviceNode<any, any, any, any>> {
+		nodeDefId: "FIREPLACE";
+	}
+	export function is(node: ISYNode<any, any, any, any>): node is FireplaceNode {
+		return node.nodeDefId === nodeDefId;
+	}
+	export function create(isy: ISY, nodeInfo: NodeInfo) {
+		return new FireplaceNode(isy, nodeInfo);
+	}
+	export const Node = FireplaceNode;
+	export type Commands = {
+		DON: (() => Promise<boolean>) & {
+			label: "On";
+			name: "on";
+		};
+		DOF: (() => Promise<boolean>) & {
+			label: "Off";
+			name: "off";
+		};
+	};
+	export type Drivers = {
+		ST: {
+			uom: UnitOfMeasure.OffOn;
+			value: (0 | 100 | 101);
+			label: "Status";
+			name: "status";
+		};
+	};
+}