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

package/src/Model/ClusterMap.ts

@@ -0,0 +1,195 @@
+import * as Clusters from '@project-chip/matter.js/cluster';
+import { Driver, DriverType } from '../Definitions/Global/Drivers.js';
+import { Behavior } from '@project-chip/matter.js/behavior';
+import { ClusterBehavior } from '@project-chip/matter.js/behavior/cluster';
+import type { OnOffBehavior } from '@project-chip/matter.js/behaviors/on-off';
+import { type Device, type DeviceTypeDefinition, type OnOffBaseDevice } from '@project-chip/matter.js/device';
+import { OnOffLightDevice } from '@project-chip/matter.js/devices/OnOffLightDevice';
+import { SupportedBehaviors } from '@project-chip/matter.js/endpoint/properties';
+import type { MutableEndpoint } from '@project-chip/matter.js/endpoint/type';
+import type { Identity } from '@project-chip/matter.js/util';
+import test from 'node:test';
+import { Devices, type ToDevice } from '../Devices/index.js';
+import { Family, InsteonRelayDevice } from '../ISY.js';
+import type { ISYDevice } from '../ISYDevice.js';
+import type { CommandsOf, DriversOf, ISYNode } from '../ISYNode.js';
+import type { ClusterForBehavior } from '../Matter/Behaviors/ISYClusterBehavior.js';
+import { ClusterType } from './ClusterType.js';
+
+export type AttributeMapping<B, D> =
+	B extends { cluster: { attributes: infer E extends { [K in string]: Clusters.ClusterType.Attribute } } } ?
+		Partial<Record<keyof E, keyof DriversOf<D> | { driver: keyof DriversOf<D>; converter?: string }>>
+	:	never;
+export type ClusterAttributeMapping<A, K> = {
+	[key in keyof Clusters.ClusterType.AttributesOf<A>]?: { driver: Extract<keyof DriversOf<K>, string>; converter?: (value: any) => any } | Extract<keyof DriversOf<K>, string>;
+};
+// export type ClusterTypeCommandMapping<A extends ClusterType, K> = {
+//   [key in keyof Clusters.ClusterType.CommandsOf<ToCompleteClusterByName<A>>]?:
+//     | { command: CommandsOf<K>; parameters?: parameterMapping }
+//     | CommandsOf<K>
+// };
+export type ClusterCommandMapping<A, K> = {
+	[key in keyof Clusters.ClusterType.CommandsOf<A>]?: { command: keyof CommandsOf<K>; parameters?: parameterMapping } | keyof CommandsOf<K>;
+};
+//export type FamilyToDeviceMap<T extends Family> = Record<keyof Devices<T>, DeviceToClusterMap<ISYDevice<T>>>;
+
+// export type ClusterTypeMapping<A extends ClusterType,K> = {
+//     attributes: ClusterTypeAttributeMapping<A,K>,
+//     commands: ClusterTypeCommandMapping<A,K>
+// };
+export type ClusterMapping<A, K> = {
+	attributes: ClusterAttributeMapping<A, K>;
+	commands: ClusterCommandMapping<A, K>;
+};
+export type CommandMapping<B, D> =
+	B extends (
+		{
+			cluster: { commands: infer E extends { [K in string]: Clusters.ClusterType.Command } };
+		}
+	) ?
+		Partial<Record<keyof E, keyof CommandsOf<D> | { command: keyof CommandsOf<D>; parameters?: parameterMapping }>>
+	:	never;
+// `${const ClusterList = Object.keys(Clusters).filter(p => p instanceof Clusters.Cluster).map(p => p.constructor.name);
+// var s = {...ClusterList};
+
+// type ClusterName = ClusterList[0] | ClusterList[1];
+
+// var ColorControl : ClusterName = "ColorControl";}`
+
+//  type ChildrenOf<T> = T extends Family.Global ? Family | ISYDevice | string :
+//                                     T extends Family ? ISYDevice | string  : string;
+
+// export type ClusterMap<T extends Family | ISYDevice<Family> | string> = T extends ISYDevice<Family>
+//   ? {
+//       deviceType: Partial<Device>;
+//       scope?: ChildrenOf<T>;
+//       mapping: [ClusterTypeMapping<ClusterType,T>];
+//       behavior?: typeof ClusterBehavior;
+//     }
+//   : {
+//       scope?: ChildrenOf<T>;
+//       mapping: [ClusterTypeMapping<ClusterType,any>];
+//       behavior?: typeof ClusterBehavior;
+//     };
+
+//ype GenericCluster = Clusters.OnOffCluster | Clusters.ColorControl.Complete | Clusters.LevelControl.Cluster;
+
+// export type DeviceToClusterMap<T extends ISYDevice<Family,any,any>> =
+// {
+//     deviceType: Partial<Device>;
+//     scope?: string;
+//     mapping: {[Type in ClusterType]?:ClusterTypeMapping<Type,T>};
+//     behavior?: typeof ClusterBehavior;
+
+// }
+export type DeviceToClusterMap<T extends ISYNode<Family, any, any, any>, D> =
+	D extends { behaviors: SupportedBehaviors; deviceType: string } ?
+		{
+			deviceType: D;
+			mapping: EndpointMapping<D, T>;
+		}
+	:	never;
+export type EndpointMapping<A extends { behaviors: any }, D> = {
+	[K in Capitalize<StringKeys<A['behaviors']>>]?: {
+		attributes?: AttributeMapping<A['behaviors'][Uncapitalize<K>], D>;
+		commands?: CommandMapping<A['behaviors'][Uncapitalize<K>], D>;
+	};
+};
+////const ClusterIdentifier = Object.values(Clusters).filter(p=> p instanceof Clusters.MutableCluster && typeof p == "object" && p.constructor.name.endsWith(".Cluster"));
+//type clusterList = keyof typeof ClusterIdentifier;
+
+// export type ClusterMappings = {
+//    OnOffCluster: ClusterTypeMapping<ClusterType.OnOff,ISYDevice<Family>>
+// }
+
+//| typeof ISYDevice<any, infer B, any>
+
+// export type ClusterTypeAttributeMapping<A extends ClusterType, K> = {
+//   [key in keyof Clusters.ClusterType.AttributesOf<ToCompleteClusterByName<A>>]?:
+//     | { driver: DriversOf<K>; converter?: string }
+//     | DriversOf<K>;
+// };
+export type EndpointMapping1<A extends MutableEndpoint, K> = {
+	attributes?: SBAttributeMapping<A['behaviors'], K>;
+	commands?: SBCommandMapping<A['behaviors'], K>;
+};
+export type FamilyToClusterMap<T extends Family.Insteon | Family.ZWave | Family.ZigBee> = {
+	[Type in keyof Devices.Insteon]?: DeviceToClusterMap<InstanceType<Devices.Insteon[Type]>, any>;
+};
+export type SBAttributeMapping<SB extends SupportedBehaviors, D> = {
+	[K in keyof SB]: Partial<Record<keyof Behavior.StateOf<SB[K]>, DriversOf<D> | { driver: DriversOf<D>; converter?: string }>>;
+};
+export type SBCommandMapping<SB extends SupportedBehaviors, D> = {
+	//@ts-expect-error
+	[K in Capitalize<keyof SB>]?: SB[Uncapitalize<K>] extends { cluster: { commands } } ? Partial<Record<string, CommandsOf<D> | { driver: DriversOf<D>; converter?: string }>> : never;
+};
+type StringKeys<T> = Extract<keyof T, string>;
+type a = Clusters.ClusterType.CommandsOf<OnOffLightDevice['behaviors']['onOff']['cluster']>;
+type d = FamilyToClusterMap<Family.Insteon>;
+export type parameterMapping = {
+	[key: string]: { parameter: string; converter?: string };
+};
+
+// #endregion Type aliases (15)
+
+// #region Classes (1)
+
+export class MappingRegistry {
+	// #region Properties (1)
+
+	public static map: Map<string, DeviceToClusterMap<any, any>> = new Map();
+
+	// #endregion Properties (1)
+
+	// #region Public Static Methods (3)
+
+	public static getMapping<T extends ISYDevice<any, any, any>>(device: T) {
+		return MappingRegistry.map.get(device.constructor.name);
+	}
+
+	public static getMappingForBehavior<T extends ISYDevice<any, any, any>, B extends ClusterBehavior>(device: T, behavior: B): ClusterMapping<B['cluster'], T> {
+		var m = MappingRegistry.getMapping(device);
+
+		return m[behavior.cluster.name];
+		// for(var m in MappingRegistry.getMapping(device).mapping)
+		// {
+		//   if(behavior.cluster.name === m)
+		//     return MappingRegistry.getMapping(device).mapping[m];
+
+		// }
+	}
+
+	public static register(map: Partial<FamilyToClusterMap<any>>) {
+		for (var key in map) {
+			MappingRegistry.map.set(key, map[key]);
+		}
+	}
+
+	// #endregion Public Static Methods (3)
+}
+
+// #endregion Classes (1)
+
+// #region Variables (3)
+
+var teest: d;
+var clusterMap = {
+	cluster: ClusterType.ColorControl,
+	attributes: { colorTemperatureMireds: { driver: DriverType.Status } },
+	commands: {
+		moveToColor: { command: DriverType.CustomControl1, parameters: { colorX: { parameter: 'colorX' }, colorY: { parameter: 'colorY' }, colorTemperature: { parameter: 'colorTemperature' } } }
+	}
+};
+const map: EndpointMapping<OnOffLightDevice, InsteonRelayDevice> = {
+	Identify: {},
+	OnOff: {
+		attributes: {
+			onOff: { driver: 'ST' }
+		},
+		commands: {
+			onWithTimedOff: { command: 'DON' }
+		}
+	}
+};
+
+// #endregion Variables (3)

package/src/Model/ClusterType.ts

@@ -0,0 +1,365 @@
+
+
+import * as Clusters from '@project-chip/matter.js/cluster';
+
+export enum ClusterType {
+  AccessControl = "AccessControl",
+  AccountLogin = "AccountLogin",
+  Actions = "Actions",
+  ActivatedCarbonFilterMonitoring = "ActivatedCarbonFilterMonitoring",
+  AdministratorCommissioning = "AdministratorCommissioning",
+  AirQuality = "AirQuality",
+  AlarmBase = "AlarmBase",
+  ApplicationBasic = "ApplicationBasic",
+  ApplicationLauncher = "ApplicationLauncher",
+  AudioOutput = "AudioOutput",
+  BallastConfiguration = "BallastConfiguration",
+  BasicInformation = "BasicInformation",
+  Binding = "Binding",
+  BooleanState = "BooleanState",
+  BooleanStateConfiguration = "BooleanStateConfiguration",
+  BridgedDeviceBasicInformation = "BridgedDeviceBasicInformation",
+  CarbonDioxideConcentrationMeasurement = "CarbonDioxideConcentrationMeasurement",
+  CarbonMonoxideConcentrationMeasurement = "CarbonMonoxideConcentrationMeasurement",
+  Channel = "Channel",
+  ColorControl = "ColorControl",
+  ConcentrationMeasurement = "ConcentrationMeasurement",
+  ContentAppObserver = "ContentAppObserver",
+  ContentControl = "ContentControl",
+  ContentLauncher = "ContentLauncher",
+  Descriptor = "Descriptor",
+  DeviceEnergyManagement = "DeviceEnergyManagement",
+  DeviceEnergyManagementMode = "DeviceEnergyManagementMode",
+  DiagnosticLogs = "DiagnosticLogs",
+  DishwasherAlarm = "DishwasherAlarm",
+  DishwasherMode = "DishwasherMode",
+  DoorLock = "DoorLock",
+  ElectricalEnergyMeasurement = "ElectricalEnergyMeasurement",
+  ElectricalPowerMeasurement = "ElectricalPowerMeasurement",
+  EnergyEvse = "EnergyEvse",
+  EnergyEvseMode = "EnergyEvseMode",
+  EnergyPreference = "EnergyPreference",
+  EthernetNetworkDiagnostics = "EthernetNetworkDiagnostics",
+  FanControl = "FanControl",
+  FixedLabel = "FixedLabel",
+  FlowMeasurement = "FlowMeasurement",
+  FormaldehydeConcentrationMeasurement = "FormaldehydeConcentrationMeasurement",
+  GeneralCommissioning = "GeneralCommissioning",
+  GeneralDiagnostics = "GeneralDiagnostics",
+  GroupKeyManagement = "GroupKeyManagement",
+  Groups = "Groups",
+  HepaFilterMonitoring = "HepaFilterMonitoring",
+  IcdManagement = "IcdManagement",
+  Identify = "Identify",
+  IlluminanceMeasurement = "IlluminanceMeasurement",
+  KeypadInput = "KeypadInput",
+  Label = "Label",
+  LaundryDryerControls = "LaundryDryerControls",
+  LaundryWasherControls = "LaundryWasherControls",
+  LaundryWasherMode = "LaundryWasherMode",
+  LevelControl = "LevelControl",
+  LocalizationConfiguration = "LocalizationConfiguration",
+  LowPower = "LowPower",
+  MediaInput = "MediaInput",
+  MediaPlayback = "MediaPlayback",
+  Messages = "Messages",
+  MicrowaveOvenControl = "MicrowaveOvenControl",
+  MicrowaveOvenMode = "MicrowaveOvenMode",
+  ModeBase = "ModeBase",
+  ModeSelect = "ModeSelect",
+  NetworkCommissioning = "NetworkCommissioning",
+  NitrogenDioxideConcentrationMeasurement = "NitrogenDioxideConcentrationMeasurement",
+  OccupancySensing = "OccupancySensing",
+  OnOff = "OnOff",
+  OperationalCredentials = "OperationalCredentials",
+  OperationalState = "OperationalState",
+  OtaSoftwareUpdateProvider = "OtaSoftwareUpdateProvider",
+  OtaSoftwareUpdateRequestor = "OtaSoftwareUpdateRequestor",
+  OvenCavityOperationalState = "OvenCavityOperationalState",
+  OvenMode = "OvenMode",
+  OzoneConcentrationMeasurement = "OzoneConcentrationMeasurement",
+  Pm10ConcentrationMeasurement = "Pm10ConcentrationMeasurement",
+  Pm1ConcentrationMeasurement = "Pm1ConcentrationMeasurement",
+  Pm2 = "Pm2",
+  PowerSource = "PowerSource",
+  PowerSourceConfiguration = "PowerSourceConfiguration",
+  PowerTopology = "PowerTopology",
+  PressureMeasurement = "PressureMeasurement",
+  ProxyConfiguration = "ProxyConfiguration",
+  ProxyDiscovery = "ProxyDiscovery",
+  PulseWidthModulation = "PulseWidthModulation",
+  PumpConfigurationAndControl = "PumpConfigurationAndControl",
+  RadonConcentrationMeasurement = "RadonConcentrationMeasurement",
+  RefrigeratorAlarm = "RefrigeratorAlarm",
+  RefrigeratorAndTemperatureControlledCabinetMode = "RefrigeratorAndTemperatureControlledCabinetMode",
+  RelativeHumidityMeasurement = "RelativeHumidityMeasurement",
+  ResourceMonitoring = "ResourceMonitoring",
+  RvcCleanMode = "RvcCleanMode",
+  RvcOperationalState = "RvcOperationalState",
+  RvcRunMode = "RvcRunMode",
+  ScenesManagement = "ScenesManagement",
+  SmokeCoAlarm = "SmokeCoAlarm",
+  SoftwareDiagnostics = "SoftwareDiagnostics",
+  Switch = "Switch",
+  TargetNavigator = "TargetNavigator",
+  TemperatureControl = "TemperatureControl",
+  TemperatureMeasurement = "TemperatureMeasurement",
+  Thermostat = "Thermostat",
+  ThermostatUserInterfaceConfiguration = "ThermostatUserInterfaceConfiguration",
+  ThreadNetworkDiagnostics = "ThreadNetworkDiagnostics",
+  TimeFormatLocalization = "TimeFormatLocalization",
+  TimeSynchronization = "TimeSynchronization",
+  TotalVolatileOrganicCompoundsConcentrationMeasurement = "TotalVolatileOrganicCompoundsConcentrationMeasurement",
+  UnitLocalization = "UnitLocalization",
+  UserLabel = "UserLabel",
+  ValidProxies = "ValidProxies",
+  ValveConfigurationAndControl = "ValveConfigurationAndControl",
+  WakeOnLan = "WakeOnLan",
+  WiFiNetworkDiagnostics = "WiFiNetworkDiagnostics",
+  WindowCovering = "WindowCovering"
+}
+// export function ToCluster(clusterType: ClusterType) {
+//   switch (clusterType) {
+//     case ClusterType.AccessControl:
+//       return AccessControl.Complete;
+//     case ClusterType.AccountLogin:
+//       return AccountLogin.Complete;
+//     case ClusterType.Actions:
+//       return Actions.Complete;
+//     case ClusterType.ActivatedCarbonFilterMonitoring:
+//       return ActivatedCarbonFilterMonitoring.Complete;
+//     case ClusterType.AdministratorCommissioning:
+//       return AdministratorCommissioning.Complete;
+//     case ClusterType.AirQuality:
+//       return AirQuality.Complete;
+//     case ClusterType.AlarmBase:
+//       return AlarmBase.Complete;
+//     case ClusterType.ApplicationBasic:
+//       return ApplicationBasic.Complete;
+//     case ClusterType.ApplicationLauncher:
+//       return ApplicationLauncher.Complete;
+//     case ClusterType.AudioOutput:
+//       return AudioOutput.Complete;
+//     case ClusterType.BallastConfiguration:
+//       return BallastConfiguration.Complete;
+//     case ClusterType.BasicInformation:
+//       return BasicInformation.Complete;
+//     case ClusterType.Binding:
+//       return Binding.Complete;
+//     case ClusterType.BooleanState:
+//       return BooleanState.Complete;
+//     case ClusterType.BooleanStateConfiguration:
+//       return BooleanStateConfiguration.Complete;
+//     case ClusterType.BridgedDeviceBasicInformation:
+//       return BridgedDeviceBasicInformation.Complete;
+//     case ClusterType.CarbonDioxideConcentrationMeasurement:
+//       return CarbonDioxideConcentrationMeasurement.Complete;
+//     case ClusterType.CarbonMonoxideConcentrationMeasurement:
+//       return CarbonMonoxideConcentrationMeasurement.Complete;
+//     case ClusterType.Channel:
+//       return Channel.Complete;
+//     case ClusterType.ColorControl:
+//       return ColorControl.Complete;
+//     case ClusterType.ConcentrationMeasurement:
+//       return ConcentrationMeasurement.Complete;
+//     case ClusterType.ContentAppObserver:
+//       return ContentAppObserver.Complete;
+//     case ClusterType.ContentControl:
+//       return ContentControl.Complete;
+//     case ClusterType.ContentLauncher:
+//       return ContentLauncher.Complete;
+//     case ClusterType.Descriptor:
+//       return Descriptor.Complete;
+//     case ClusterType.DeviceEnergyManagement:
+//       return DeviceEnergyManagement.Complete;
+//     case ClusterType.DeviceEnergyManagementMode:
+//       return DeviceEnergyManagementMode.Complete;
+//     case ClusterType.DiagnosticLogs:
+//       return DiagnosticLogs.Complete;
+//     case ClusterType.DishwasherAlarm:
+//       return DishwasherAlarm.Complete;
+//     case ClusterType.DishwasherMode:
+//       return DishwasherMode.Complete;
+//     case ClusterType.DoorLock:
+//       return DoorLock.Complete;
+//     case ClusterType.ElectricalEnergyMeasurement:
+//       return ElectricalEnergyMeasurement.Complete;
+//     case ClusterType.ElectricalPowerMeasurement:
+//       return ElectricalPowerMeasurement.Complete;
+//     case ClusterType.EnergyEvse:
+//       return EnergyEvse.Complete;
+//     case ClusterType.EnergyEvseMode:
+//       return EnergyEvseMode.Complete;
+//     case ClusterType.EnergyPreference:
+//       return EnergyPreference.Complete;
+//     case ClusterType.EthernetNetworkDiagnostics:
+//       return EthernetNetworkDiagnostics.Complete;
+//     case ClusterType.FanControl:
+//       return FanControl.Complete;
+//     case ClusterType.FixedLabel:
+//       return FixedLabel.Complete;
+//     case ClusterType.FlowMeasurement:
+//       return FlowMeasurement.Complete;
+//     case ClusterType.FormaldehydeConcentrationMeasurement:
+//       return FormaldehydeConcentrationMeasurement.Complete;
+//     case ClusterType.GeneralCommissioning:
+//       return GeneralCommissioning.Complete;
+//     case ClusterType.GeneralDiagnostics:
+//       return GeneralDiagnostics.Complete;
+//     case ClusterType.GroupKeyManagement:
+//       return GroupKeyManagement.Complete;
+//     case ClusterType.Groups:
+//       return Groups.Complete;
+//     case ClusterType.HepaFilterMonitoring:
+//       return HepaFilterMonitoring.Complete;
+//     case ClusterType.IcdManagement:
+//       return IcdManagement.Complete;
+//     case ClusterType.Identify:
+//       return Identify.Complete;
+//     case ClusterType.IlluminanceMeasurement:
+//       return IlluminanceMeasurement.Complete;
+//     case ClusterType.KeypadInput:
+//       return KeypadInput.Complete;
+//     case ClusterType.Label:
+//       return Label.Complete;
+//     case ClusterType.LaundryDryerControls:
+//       return LaundryDryerControls.Complete;
+//     case ClusterType.LaundryWasherControls:
+//       return LaundryWasherControls.Complete;
+//     case ClusterType.LaundryWasherMode:
+//       return LaundryWasherMode.Complete;
+//     case ClusterType.LevelControl:
+//       return LevelControl.Complete;
+//     case ClusterType.LocalizationConfiguration:
+//       return LocalizationConfiguration.Complete;
+//     case ClusterType.LowPower:
+//       return LowPower.Complete;
+//     case ClusterType.MediaInput:
+//       return MediaInput.Complete;
+//     case ClusterType.MediaPlayback:
+//       return MediaPlayback.Complete;
+//     case ClusterType.Messages:
+//       return Messages.Complete;
+//     case ClusterType.MicrowaveOvenControl:
+//       return MicrowaveOvenControl.Complete;
+//     case ClusterType.MicrowaveOvenMode:
+//       return MicrowaveOvenMode.Complete;
+//     case ClusterType.ModeBase:
+//       return ModeBase.Complete;
+//     case ClusterType.ModeSelect:
+//       return ModeSelect.Complete;
+//     case ClusterType.NetworkCommissioning:
+//       return NetworkCommissioning.Complete;
+//     case ClusterType.NitrogenDioxideConcentrationMeasurement:
+//       return NitrogenDioxideConcentrationMeasurement.Complete;
+//     case ClusterType.OccupancySensing:
+//       return OccupancySensing.Complete;
+//     case ClusterType.OnOff:
+//       return OnOff.Complete;
+//     case ClusterType.OperationalCredentials:
+//       return OperationalCredentials.Complete;
+//     case ClusterType.OperationalState:
+//       return OperationalState.Complete;
+//     case ClusterType.OtaSoftwareUpdateProvider:
+//       return OtaSoftwareUpdateProvider.Complete;
+//     case ClusterType.OtaSoftwareUpdateRequestor:
+//       return OtaSoftwareUpdateRequestor.Complete;
+//     case ClusterType.OvenCavityOperationalState:
+//       return OvenCavityOperationalState.Complete;
+//     case ClusterType.OvenMode:
+//       return OvenMode.Complete;
+//     case ClusterType.OzoneConcentrationMeasurement:
+//       return OzoneConcentrationMeasurement.Complete;
+//     case ClusterType.Pm10ConcentrationMeasurement:
+//       return Pm10ConcentrationMeasurement.Complete;
+//     case ClusterType.Pm1ConcentrationMeasurement:
+//       return Pm1ConcentrationMeasurement.Complete;
+//     case ClusterType.Pm2:
+//       return Pm2.Complete;
+//     case ClusterType.PowerSource:
+//       return PowerSource.Complete;
+//     case ClusterType.PowerSourceConfiguration:
+//       return PowerSourceConfiguration.Complete;
+//     case ClusterType.PowerTopology:
+//       return PowerTopology.Complete;
+//     case ClusterType.PressureMeasurement:
+//       return PressureMeasurement.Complete;
+//     case ClusterType.ProxyConfiguration:
+//       return ProxyConfiguration.Complete;
+//     case ClusterType.ProxyDiscovery:
+//       return ProxyDiscovery.Complete;
+//     case ClusterType.PulseWidthModulation:
+//       return PulseWidthModulation.Complete;
+//     case ClusterType.PumpConfigurationAndControl:
+//       return PumpConfigurationAndControl.Complete;
+//     case ClusterType.RadonConcentrationMeasurement:
+//       return RadonConcentrationMeasurement.Complete;
+//     case ClusterType.RefrigeratorAlarm:
+//       return RefrigeratorAlarm.Complete;
+//     case ClusterType.RefrigeratorAndTemperatureControlledCabinetMode:
+//       return RefrigeratorAndTemperatureControlledCabinetMode.Complete;
+//     case ClusterType.RelativeHumidityMeasurement:
+//       return RelativeHumidityMeasurement.Complete;
+//     case ClusterType.ResourceMonitoring:
+//       return ResourceMonitoring.Complete;
+//     case ClusterType.RvcCleanMode:
+//       return RvcCleanMode.Complete;
+//     case ClusterType.RvcOperationalState:
+//       return RvcOperationalState.Complete;
+//     case ClusterType.RvcRunMode:
+//       return RvcRunMode.Complete;
+//     case ClusterType.ScenesManagement:
+//       return ScenesManagement.Complete;
+//     case ClusterType.SmokeCoAlarm:
+//       return SmokeCoAlarm.Complete;
+//     case ClusterType.SoftwareDiagnostics:
+//       return SoftwareDiagnostics.Complete;
+//     case ClusterType.Switch:
+//       return Switch.Complete;
+//     case ClusterType.TargetNavigator:
+//       return TargetNavigator.Complete;
+//     case ClusterType.TemperatureControl:
+//       return TemperatureControl.Complete;
+//     case ClusterType.TemperatureMeasurement:
+//       return TemperatureMeasurement.Complete;
+//     case ClusterType.Thermostat:
+//       return Thermostat.Complete;
+//     case ClusterType.ThermostatUserInterfaceConfiguration:
+//       return ThermostatUserInterfaceConfiguration.Complete;
+//     case ClusterType.ThreadNetworkDiagnostics:
+//       return ThreadNetworkDiagnostics.Complete;
+//     case ClusterType.TimeFormatLocalization:
+//       return TimeFormatLocalization.Complete;
+//     case ClusterType.TimeSynchronization:
+//       return TimeSynchronization.Complete;
+//     case ClusterType.TotalVolatileOrganicCompoundsConcentrationMeasurement:
+//       return TotalVolatileOrganicCompoundsConcentrationMeasurement.Complete;
+//     case ClusterType.UnitLocalization:
+//       return UnitLocalization.Complete;
+//     case ClusterType.UserLabel:
+//       return UserLabel.Complete;
+//     case ClusterType.ValidProxies:
+//       return ValidProxies.Complete;
+//     case ClusterType.ValveConfigurationAndControl:
+//       return ValveConfigurationAndControl.Complete;
+//     case ClusterType.WakeOnLan:
+//       return WakeOnLan.Complete;
+//     case ClusterType.WiFiNetworkDiagnostics:
+//       return WiFiNetworkDiagnostics.Complete;
+//     case ClusterType.WindowCovering:
+//       return WindowCovering.Complete;
+//   }
+// }
+
+
+
+//export type ToCompleteClusterByName<E extends ClusterType> = (typeof Clusters[`${E}`][];
+//export type ToClusterByName<E extends ClusterType | keyof typeof Clusters> = (typeof Clusters)[`${E}`];
+
+export type ToClusterTypeByName<E extends string> = E extends keyof typeof ClusterType ? typeof ClusterType[E] : never;
+
+///type s = ToCluster<"OnOff">;
+
+export type ToClusterType<E extends Clusters.MutableCluster<any>> = E extends Clusters.MutableCluster<infer C> ? C : {};
+
+type o = ToClusterType<Clusters.OnOffCluster>;

package/src/Model/CodeGeneration/EventDef.ts

@@ -0,0 +1,36 @@
+import type { Family, UnitOfMeasure } from '../../Definitions/Global/index.js'
+import { type EditorDef, EditorDefMap } from '../EditorDef.js';
+
+interface EventMaps {
+  '$comment': string;
+  eventMap: EventMap;
+}
+
+interface EventMap {
+  uomMap: UomMap;
+  id: string;
+}
+
+interface UomMap {
+    uom: {
+    from: UnitOfMeasure;
+    to: UnitOfMeasure;
+    prec?: number;
+ }[]
+  '$comment': string[];
+}
+
+export const UOMMap : Map<Family, {[x in UnitOfMeasure]?: UnitOfMeasure} > = new Map();
+
+export function buildUOMMap<T extends Family>(eventMaps: UomMap, family: T) {
+    let map: {[x in UnitOfMeasure]?: UnitOfMeasure} = {};
+
+    for (const uom of eventMaps.uom) {
+        map[uom.to] = uom.from as UnitOfMeasure;
+    }
+
+
+    UOMMap.set(family, map);
+    return map;
+}
+

package/src/Model/Config.ts

@@ -0,0 +1,94 @@
+export interface DeviceSpec {
+	make: string;
+	manufacturerURL: string;
+	model: string;
+	icon: string;
+	archive: string;
+	chart: string;
+	queryOnInit: boolean;
+	oneNodeAtATime: boolean;
+	baseProtocolOptional: boolean;
+}
+
+export interface UpnpDevice {
+	utype: string;
+	version: number;
+}
+
+export interface UpnpService {
+	utype: string;
+	version: number;
+}
+
+export interface UpnpSpec {
+	upnpDevice: UpnpDevice;
+	upnpService: UpnpService;
+}
+
+export interface Control {
+	iD: number;
+	name: string;
+	label: string;
+	readOnly: boolean;
+	isQueryAble: boolean;
+	isNumeric: boolean;
+	numericUnit: string;
+}
+
+export interface Control {
+	control: Control[];
+}
+
+export interface Root {
+	id: string;
+	name: string;
+}
+
+export interface Product {
+	id: number;
+	desc: string;
+}
+
+export interface Feature {
+	id: number;
+	desc: string;
+	isInstalled: boolean;
+	isAvailable: boolean;
+}
+
+export interface Feature {
+	feature: Feature[];
+}
+
+export interface BaseDriver {
+	type: string;
+	version: number;
+}
+
+export interface Security {
+	_: string;
+	v: number;
+}
+
+export interface Config {
+	deviceSpecs: DeviceSpec;
+	upnpSpecs: UpnpSpec;
+	controls: Control;
+	driver_timestamp: string;
+	app: string;
+	app_version: string;
+	app_full_version: string;
+	platform: string;
+	build_timestamp: string;
+	root: Root;
+	product: Product;
+	features: Feature;
+	triggers: boolean;
+	maxTriggers: number;
+	variables: boolean;
+	nodedefs: boolean;
+	baseDriver: BaseDriver;
+	security: Security;
+	isDefaultCert: boolean;
+	maxSSLStrength: number;
+}