@matter/model 0.11.0-alpha.0-20241005-e3e4e4a7a

package/src/standard/elements/list.ts

@@ -0,0 +1,104 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
+
+import { MatterDefinition } from "../MatterDefinition.js";
+import { DatatypeElement as Datatype } from "../../elements/index.js";
+
+export const list = Datatype({
+    name: "list", description: "List", isSeed: true, metatype: "array",
+
+    details: "A list is defined as a collection of entries of the same data type, with a finite count from 0 to " +
+        "65534. A cluster specification may define further constraints on the maximum possible count. The " +
+        "list entry data type shall be any defined data type, except a list data type, or any data type " +
+        "derived from a list." +
+        "\n" +
+        "The quality columns for a list definition are for the list." +
+        "\n" +
+        "The list entries are indicated with an index that is an unsigned integer starting at 0 (zero). The " +
+        "maintained order of entries, by index, is defined in the cluster specification, or undefined. Data " +
+        "that is defined as a list is indicated with \"list[X]\" where X is the entry type. The data type of " +
+        "the list entry has its own qualities, constraints, and conformance." +
+        "\n" +
+        "### To define qualities for the list entry data type, make the list entry data type a defined local " +
+        "derived data type, with a table including the columns required to define and constrain the data " +
+        "type." +
+        "\n" +
+        "There is an inline shortcut to define the list entry data type constraints. See List Constraints." +
+        "\n" +
+        "It is recommended to put a maximum constraint on the list and list entry data types." +
+        "\n" +
+        "It is recommended that a list entry data type be a struct, to enable the addition of new fields to " +
+        "the list’s entries in the future." +
+        "\n" +
+        "  • The cluster data version shall be incremented when the list order or entries change." +
+        "\n" +
+        "  • An entry shall NOT be null." +
+        "\n" +
+        "  • The list shall support reading and reporting all entries." +
+        "\n" +
+        "  • The list shall support reporting, updates, and/or deletion of one or more entries." +
+        "\n" +
+        "  • If the list is writable, it shall support writing or deleting the entire list." +
+        "\n" +
+        "  • If the list is writable, it shall support updating one or more individual entries by indicating " +
+        "    an index per updated entry." +
+        "\n" +
+        "  • If the list is writable, it shall support deleting one or more individual entries by indicating " +
+        "    an index per deleted entry." +
+        "\n" +
+        "  • If the list is writable, it shall support adding one or more individual entries." +
+        "\n" +
+        "  • A list may define an entry that is a struct that is fabric-scoped (see Fabric-Scoped Quality)." +
+        "\n" +
+        "### Fabric-Scoped List" +
+        "\n" +
+        "  • A fabric-scoped list shall define an entry data type that is a struct, which shall also be " +
+        "    fabric-scoped (see Fabric-Scoped Struct)." +
+        "\n" +
+        "Each entry in a fabric-scoped list shall be fabric-scoped to a particular fabric or no fabric." +
+        "\n" +
+        "### A fabric-scoped list supports a fabric-filter that filters the view of the list for read and " +
+        "write interactions. This filter simplifies client side logic that does not want to read or write " +
+        "fabric data that is not associated with the accessing fabric." +
+        "\n" +
+        "  • An interaction upon a list with fabric-filtering shall only indicate and access entries where " +
+        "    the associated fabric matches the accessing fabric, and all other entries shall be ignored." +
+        "\n" +
+        "  • Fabric-filtered list entries shall be in the same order as the full list." +
+        "\n" +
+        "  • Fabric-filtered list entries shall be indexed from 0 with no gaps, as if the other entries did " +
+        "    not exist." +
+        "\n" +
+        "  • For a write interaction, fabric-filtering shall be enabled." +
+        "\n" +
+        "  • When writing to a fabric-scoped list, the write interaction shall be on an accessing fabric, " +
+        "    otherwise, the write interaction shall fail (see Interaction Model)." +
+        "\n" +
+        "  • For a read interaction on a list, fabric-filtering may be enabled." +
+        "\n" +
+        "  • For a read interaction on a list, with fabric-filtering disabled, the list shall be reported as " +
+        "    a full list with all entries." +
+        "\n" +
+        "list[1] = [ { FabricIndex = B, Value = 55 } ]" +
+        "\n" +
+        "changes the full list to:" +
+        "\n" +
+        "list = [ { FabricIndex = A, Value = 20 }," +
+        "\n" +
+        "{ FabricIndex = B, Value = 30 }," +
+        "\n" +
+        "{ FabricIndex = A, Value = 40 }," +
+        "\n" +
+        "{ FabricIndex = B, Value = 55 }," +
+        "\n" +
+        "{ FabricIndex = B, Value = 60 } ]",
+
+    xref: { document: "core", section: "7.18.1.8" }
+});
+
+MatterDefinition.children.push(list);

package/src/standard/elements/map16.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
+
+import { MatterDefinition } from "../MatterDefinition.js";
+import { DatatypeElement as Datatype } from "../../elements/index.js";
+
+export const map16 = Datatype({
+    name: "map16", byteSize: 2, description: "16-bit bitmap", isSeed: true, metatype: "bitmap",
+    xref: { document: "core", section: "7.18.1" }
+});
+MatterDefinition.children.push(map16);

package/src/standard/elements/map32.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
+
+import { MatterDefinition } from "../MatterDefinition.js";
+import { DatatypeElement as Datatype } from "../../elements/index.js";
+
+export const map32 = Datatype({
+    name: "map32", byteSize: 4, description: "32-bit bitmap", isSeed: true, metatype: "bitmap",
+    xref: { document: "core", section: "7.18.1" }
+});
+MatterDefinition.children.push(map32);

package/src/standard/elements/map64.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
+
+import { MatterDefinition } from "../MatterDefinition.js";
+import { DatatypeElement as Datatype } from "../../elements/index.js";
+
+export const map64 = Datatype({
+    name: "map64", byteSize: 8, description: "64-bit bitmap", isSeed: true, metatype: "bitmap",
+    xref: { document: "core", section: "7.18.1" }
+});
+MatterDefinition.children.push(map64);

package/src/standard/elements/map8.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
+
+import { MatterDefinition } from "../MatterDefinition.js";
+import { DatatypeElement as Datatype } from "../../elements/index.js";
+
+export const map8 = Datatype({
+    name: "map8", byteSize: 1, description: "8-bit bitmap", isSeed: true, metatype: "bitmap",
+    xref: { document: "core", section: "7.18.1" }
+});
+MatterDefinition.children.push(map8);

package/src/standard/elements/models.ts

@@ -0,0 +1,291 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
+
+import * as definitions from "./definitions.js";
+import { ClusterModel } from "../../models/ClusterModel.js";
+import { DatatypeModel } from "../../models/DatatypeModel.js";
+import { AttributeModel } from "../../models/AttributeModel.js";
+import { FieldModel } from "../../models/FieldModel.js";
+import { DeviceTypeModel } from "../../models/DeviceTypeModel.js";
+import { SemanticNamespaceModel } from "../../models/SemanticNamespaceModel.js";
+
+export const Identify = new ClusterModel(definitions.Identify);
+export const Groups = new ClusterModel(definitions.Groups);
+export const ScenesManagement = new ClusterModel(definitions.ScenesManagement);
+export const OnOff = new ClusterModel(definitions.OnOff);
+export const LevelControl = new ClusterModel(definitions.LevelControl);
+export const PulseWidthModulation = new ClusterModel(definitions.PulseWidthModulation);
+export const BooleanState = new ClusterModel(definitions.BooleanState);
+export const BooleanStateConfiguration = new ClusterModel(definitions.BooleanStateConfiguration);
+export const ModeSelect = new ClusterModel(definitions.ModeSelect);
+export const ModeBase = new ClusterModel(definitions.ModeBase);
+export const LowPower = new ClusterModel(definitions.LowPower);
+export const WakeOnLan = new ClusterModel(definitions.WakeOnLan);
+export const Switch = new ClusterModel(definitions.Switch);
+export const OperationalState = new ClusterModel(definitions.OperationalState);
+export const AlarmBase = new ClusterModel(definitions.AlarmBase);
+export const Messages = new ClusterModel(definitions.Messages);
+export const IlluminanceMeasurement = new ClusterModel(definitions.IlluminanceMeasurement);
+export const TemperatureMeasurement = new ClusterModel(definitions.TemperatureMeasurement);
+export const PressureMeasurement = new ClusterModel(definitions.PressureMeasurement);
+export const FlowMeasurement = new ClusterModel(definitions.FlowMeasurement);
+export const RelativeHumidityMeasurement = new ClusterModel(definitions.RelativeHumidityMeasurement);
+export const OccupancySensing = new ClusterModel(definitions.OccupancySensing);
+export const ResourceMonitoring = new ClusterModel(definitions.ResourceMonitoring);
+export const HepaFilterMonitoring = new ClusterModel(definitions.HepaFilterMonitoring);
+export const ActivatedCarbonFilterMonitoring = new ClusterModel(definitions.ActivatedCarbonFilterMonitoring);
+export const AirQuality = new ClusterModel(definitions.AirQuality);
+export const ConcentrationMeasurement = new ClusterModel(definitions.ConcentrationMeasurement);
+export const CarbonMonoxideConcentrationMeasurement = new ClusterModel(definitions.CarbonMonoxideConcentrationMeasurement);
+export const CarbonDioxideConcentrationMeasurement = new ClusterModel(definitions.CarbonDioxideConcentrationMeasurement);
+export const NitrogenDioxideConcentrationMeasurement = new ClusterModel(definitions.NitrogenDioxideConcentrationMeasurement);
+export const OzoneConcentrationMeasurement = new ClusterModel(definitions.OzoneConcentrationMeasurement);
+export const Pm25ConcentrationMeasurement = new ClusterModel(definitions.Pm25ConcentrationMeasurement);
+export const FormaldehydeConcentrationMeasurement = new ClusterModel(definitions.FormaldehydeConcentrationMeasurement);
+export const Pm1ConcentrationMeasurement = new ClusterModel(definitions.Pm1ConcentrationMeasurement);
+export const Pm10ConcentrationMeasurement = new ClusterModel(definitions.Pm10ConcentrationMeasurement);
+export const TotalVolatileOrganicCompoundsConcentrationMeasurement = new ClusterModel(definitions.TotalVolatileOrganicCompoundsConcentrationMeasurement);
+export const RadonConcentrationMeasurement = new ClusterModel(definitions.RadonConcentrationMeasurement);
+export const SmokeCoAlarm = new ClusterModel(definitions.SmokeCoAlarm);
+export const ElectricalEnergyMeasurement = new ClusterModel(definitions.ElectricalEnergyMeasurement);
+export const ElectricalPowerMeasurement = new ClusterModel(definitions.ElectricalPowerMeasurement);
+export const ColorControl = new ClusterModel(definitions.ColorControl);
+export const BallastConfiguration = new ClusterModel(definitions.BallastConfiguration);
+export const PumpConfigurationAndControl = new ClusterModel(definitions.PumpConfigurationAndControl);
+export const Thermostat = new ClusterModel(definitions.Thermostat);
+export const FanControl = new ClusterModel(definitions.FanControl);
+export const ThermostatUserInterfaceConfiguration = new ClusterModel(definitions.ThermostatUserInterfaceConfiguration);
+export const ValveConfigurationAndControl = new ClusterModel(definitions.ValveConfigurationAndControl);
+export const DoorLock = new ClusterModel(definitions.DoorLock);
+export const WindowCovering = new ClusterModel(definitions.WindowCovering);
+export const AccountLogin = new ClusterModel(definitions.AccountLogin);
+export const ApplicationBasic = new ClusterModel(definitions.ApplicationBasic);
+export const ApplicationLauncher = new ClusterModel(definitions.ApplicationLauncher);
+export const AudioOutput = new ClusterModel(definitions.AudioOutput);
+export const Channel = new ClusterModel(definitions.Channel);
+export const ContentLauncher = new ClusterModel(definitions.ContentLauncher);
+export const KeypadInput = new ClusterModel(definitions.KeypadInput);
+export const MediaInput = new ClusterModel(definitions.MediaInput);
+export const MediaPlayback = new ClusterModel(definitions.MediaPlayback);
+export const TargetNavigator = new ClusterModel(definitions.TargetNavigator);
+export const ContentAppObserver = new ClusterModel(definitions.ContentAppObserver);
+export const ContentControl = new ClusterModel(definitions.ContentControl);
+export const RvcRunMode = new ClusterModel(definitions.RvcRunMode);
+export const RvcCleanMode = new ClusterModel(definitions.RvcCleanMode);
+export const RvcOperationalState = new ClusterModel(definitions.RvcOperationalState);
+export const TemperatureControl = new ClusterModel(definitions.TemperatureControl);
+export const DishwasherMode = new ClusterModel(definitions.DishwasherMode);
+export const DishwasherAlarm = new ClusterModel(definitions.DishwasherAlarm);
+export const LaundryWasherMode = new ClusterModel(definitions.LaundryWasherMode);
+export const LaundryWasherControls = new ClusterModel(definitions.LaundryWasherControls);
+export const RefrigeratorAndTemperatureControlledCabinetMode = new ClusterModel(definitions.RefrigeratorAndTemperatureControlledCabinetMode);
+export const RefrigeratorAlarm = new ClusterModel(definitions.RefrigeratorAlarm);
+export const LaundryDryerControls = new ClusterModel(definitions.LaundryDryerControls);
+export const OvenCavityOperationalState = new ClusterModel(definitions.OvenCavityOperationalState);
+export const OvenMode = new ClusterModel(definitions.OvenMode);
+export const MicrowaveOvenMode = new ClusterModel(definitions.MicrowaveOvenMode);
+export const MicrowaveOvenControl = new ClusterModel(definitions.MicrowaveOvenControl);
+export const DeviceEnergyManagement = new ClusterModel(definitions.DeviceEnergyManagement);
+export const EnergyEvse = new ClusterModel(definitions.EnergyEvse);
+export const EnergyEvseMode = new ClusterModel(definitions.EnergyEvseMode);
+export const EnergyPreference = new ClusterModel(definitions.EnergyPreference);
+export const DeviceEnergyManagementMode = new ClusterModel(definitions.DeviceEnergyManagementMode);
+export const Descriptor = new ClusterModel(definitions.Descriptor);
+export const Binding = new ClusterModel(definitions.Binding);
+export const Label = new ClusterModel(definitions.Label);
+export const FixedLabel = new ClusterModel(definitions.FixedLabel);
+export const UserLabel = new ClusterModel(definitions.UserLabel);
+export const AccessControl = new ClusterModel(definitions.AccessControl);
+export const BridgedDeviceBasicInformation = new ClusterModel(definitions.BridgedDeviceBasicInformation);
+export const Actions = new ClusterModel(definitions.Actions);
+export const ProxyDiscovery = new ClusterModel(definitions.ProxyDiscovery);
+export const ProxyConfiguration = new ClusterModel(definitions.ProxyConfiguration);
+export const ValidProxies = new ClusterModel(definitions.ValidProxies);
+export const IcdManagement = new ClusterModel(definitions.IcdManagement);
+export const BasicInformation = new ClusterModel(definitions.BasicInformation);
+export const GroupKeyManagement = new ClusterModel(definitions.GroupKeyManagement);
+export const LocalizationConfiguration = new ClusterModel(definitions.LocalizationConfiguration);
+export const TimeFormatLocalization = new ClusterModel(definitions.TimeFormatLocalization);
+export const UnitLocalization = new ClusterModel(definitions.UnitLocalization);
+export const PowerSourceConfiguration = new ClusterModel(definitions.PowerSourceConfiguration);
+export const PowerSource = new ClusterModel(definitions.PowerSource);
+export const PowerTopology = new ClusterModel(definitions.PowerTopology);
+export const NetworkCommissioning = new ClusterModel(definitions.NetworkCommissioning);
+export const GeneralCommissioning = new ClusterModel(definitions.GeneralCommissioning);
+export const DiagnosticLogs = new ClusterModel(definitions.DiagnosticLogs);
+export const GeneralDiagnostics = new ClusterModel(definitions.GeneralDiagnostics);
+export const SoftwareDiagnostics = new ClusterModel(definitions.SoftwareDiagnostics);
+export const ThreadNetworkDiagnostics = new ClusterModel(definitions.ThreadNetworkDiagnostics);
+export const WiFiNetworkDiagnostics = new ClusterModel(definitions.WiFiNetworkDiagnostics);
+export const EthernetNetworkDiagnostics = new ClusterModel(definitions.EthernetNetworkDiagnostics);
+export const TimeSynchronization = new ClusterModel(definitions.TimeSynchronization);
+export const OperationalCredentials = new ClusterModel(definitions.OperationalCredentials);
+export const AdministratorCommissioning = new ClusterModel(definitions.AdministratorCommissioning);
+export const OtaSoftwareUpdateProvider = new ClusterModel(definitions.OtaSoftwareUpdateProvider);
+export const OtaSoftwareUpdateRequestor = new ClusterModel(definitions.OtaSoftwareUpdateRequestor);
+export const MeasurementTypeEnum = new DatatypeModel(definitions.MeasurementTypeEnum);
+export const MeasurementAccuracyRangeStruct = new DatatypeModel(definitions.MeasurementAccuracyRangeStruct);
+export const MeasurementAccuracyStruct = new DatatypeModel(definitions.MeasurementAccuracyStruct);
+export const bool = new DatatypeModel(definitions.bool);
+export const map8 = new DatatypeModel(definitions.map8);
+export const map16 = new DatatypeModel(definitions.map16);
+export const map32 = new DatatypeModel(definitions.map32);
+export const map64 = new DatatypeModel(definitions.map64);
+export const uint8 = new DatatypeModel(definitions.uint8);
+export const uint16 = new DatatypeModel(definitions.uint16);
+export const uint24 = new DatatypeModel(definitions.uint24);
+export const uint32 = new DatatypeModel(definitions.uint32);
+export const uint40 = new DatatypeModel(definitions.uint40);
+export const uint48 = new DatatypeModel(definitions.uint48);
+export const uint56 = new DatatypeModel(definitions.uint56);
+export const uint64 = new DatatypeModel(definitions.uint64);
+export const int8 = new DatatypeModel(definitions.int8);
+export const int16 = new DatatypeModel(definitions.int16);
+export const int24 = new DatatypeModel(definitions.int24);
+export const int32 = new DatatypeModel(definitions.int32);
+export const int40 = new DatatypeModel(definitions.int40);
+export const int48 = new DatatypeModel(definitions.int48);
+export const int56 = new DatatypeModel(definitions.int56);
+export const int64 = new DatatypeModel(definitions.int64);
+export const single = new DatatypeModel(definitions.single);
+export const double = new DatatypeModel(definitions.double);
+export const octstr = new DatatypeModel(definitions.octstr);
+export const list = new DatatypeModel(definitions.list);
+export const struct = new DatatypeModel(definitions.struct);
+export const percent = new DatatypeModel(definitions.percent);
+export const percent100ths = new DatatypeModel(definitions.percent100ths);
+export const tod = new DatatypeModel(definitions.tod);
+export const date = new DatatypeModel(definitions.date);
+export const epochUs = new DatatypeModel(definitions.epochUs);
+export const epochS = new DatatypeModel(definitions.epochS);
+export const posixMs = new DatatypeModel(definitions.posixMs);
+export const systimeUs = new DatatypeModel(definitions.systimeUs);
+export const systimeMs = new DatatypeModel(definitions.systimeMs);
+export const elapsedS = new DatatypeModel(definitions.elapsedS);
+export const temperature = new DatatypeModel(definitions.temperature);
+export const powerMW = new DatatypeModel(definitions.powerMW);
+export const amperageMA = new DatatypeModel(definitions.amperageMA);
+export const voltageMV = new DatatypeModel(definitions.voltageMV);
+export const energyMWh = new DatatypeModel(definitions.energyMWh);
+export const enum8 = new DatatypeModel(definitions.enum8)
+export const enum16 = new DatatypeModel(definitions.enum16)
+export const priority = new DatatypeModel(definitions.priority);
+export const status = new DatatypeModel(definitions.status);
+export const groupId = new DatatypeModel(definitions.groupId);
+export const endpointNo = new DatatypeModel(definitions.endpointNo);
+export const vendorId = new DatatypeModel(definitions.vendorId);
+export const devtypeId = new DatatypeModel(definitions.devtypeId);
+export const fabricId = new DatatypeModel(definitions.fabricId);
+export const fabricIdx = new DatatypeModel(definitions.fabricIdx);
+export const clusterId = new DatatypeModel(definitions.clusterId);
+export const attribId = new DatatypeModel(definitions.attribId);
+export const fieldId = new DatatypeModel(definitions.fieldId);
+export const eventId = new DatatypeModel(definitions.eventId);
+export const commandId = new DatatypeModel(definitions.commandId);
+export const actionId = new DatatypeModel(definitions.actionId);
+export const transId = new DatatypeModel(definitions.transId);
+export const nodeId = new DatatypeModel(definitions.nodeId);
+export const entryIdx = new DatatypeModel(definitions.entryIdx);
+export const dataVer = new DatatypeModel(definitions.dataVer);
+export const eventNo = new DatatypeModel(definitions.eventNo);
+export const string = new DatatypeModel(definitions.string);
+export const ipadr = new DatatypeModel(definitions.ipadr);
+export const ipv4Adr = new DatatypeModel(definitions.ipv4Adr);
+export const ipv6Adr = new DatatypeModel(definitions.ipv6Adr);
+export const ipv6Pre = new DatatypeModel(definitions.ipv6Pre);
+export const hwadr = new DatatypeModel(definitions.hwadr);
+export const semtag = new DatatypeModel(definitions.semtag);
+export const namespace = new DatatypeModel(definitions.namespace)
+export const tag = new DatatypeModel(definitions.tag);
+export const WildcardPathFlagsBitmap = new DatatypeModel(definitions.WildcardPathFlagsBitmap);
+export const SoftwareVersionCertificationStatusEnum = new DatatypeModel(definitions.SoftwareVersionCertificationStatusEnum);
+export const any = new DatatypeModel(definitions.any);
+export const subjectId = new DatatypeModel(definitions.subjectId);
+export const ClusterRevision = new AttributeModel(definitions.ClusterRevision);
+export const FeatureMap = new AttributeModel(definitions.FeatureMap);
+export const AttributeList = new AttributeModel(definitions.AttributeList);
+export const EventList = new AttributeModel(definitions.EventList);
+export const AcceptedCommandList = new AttributeModel(definitions.AcceptedCommandList);
+export const GeneratedCommandList = new AttributeModel(definitions.GeneratedCommandList);
+export const FabricIndex = new FieldModel(definitions.FabricIndex);
+export const BaseDt = new DeviceTypeModel(definitions.BaseDt);
+export const RootNodeDt = new DeviceTypeModel(definitions.RootNodeDt);
+export const PowerSourceDt = new DeviceTypeModel(definitions.PowerSourceDt);
+export const OtaRequestorDt = new DeviceTypeModel(definitions.OtaRequestorDt);
+export const OtaProviderDt = new DeviceTypeModel(definitions.OtaProviderDt);
+export const BridgedNodeDt = new DeviceTypeModel(definitions.BridgedNodeDt);
+export const ElectricalSensorDt = new DeviceTypeModel(definitions.ElectricalSensorDt);
+export const DeviceEnergyManagementDt = new DeviceTypeModel(definitions.DeviceEnergyManagementDt);
+export const OnOffLightDt = new DeviceTypeModel(definitions.OnOffLightDt);
+export const DimmableLightDt = new DeviceTypeModel(definitions.DimmableLightDt);
+export const ColorTemperatureLightDt = new DeviceTypeModel(definitions.ColorTemperatureLightDt);
+export const ExtendedColorLightDt = new DeviceTypeModel(definitions.ExtendedColorLightDt);
+export const OnOffPlugInUnitDt = new DeviceTypeModel(definitions.OnOffPlugInUnitDt);
+export const DimmablePlugInUnitDt = new DeviceTypeModel(definitions.DimmablePlugInUnitDt);
+export const PumpDt = new DeviceTypeModel(definitions.PumpDt);
+export const WaterValveDt = new DeviceTypeModel(definitions.WaterValveDt);
+export const OnOffLightSwitchDt = new DeviceTypeModel(definitions.OnOffLightSwitchDt);
+export const DimmerSwitchDt = new DeviceTypeModel(definitions.DimmerSwitchDt);
+export const ColorDimmerSwitchDt = new DeviceTypeModel(definitions.ColorDimmerSwitchDt);
+export const ControlBridgeDt = new DeviceTypeModel(definitions.ControlBridgeDt);
+export const PumpControllerDt = new DeviceTypeModel(definitions.PumpControllerDt);
+export const GenericSwitchDt = new DeviceTypeModel(definitions.GenericSwitchDt);
+export const ContactSensorDt = new DeviceTypeModel(definitions.ContactSensorDt);
+export const LightSensorDt = new DeviceTypeModel(definitions.LightSensorDt);
+export const OccupancySensorDt = new DeviceTypeModel(definitions.OccupancySensorDt);
+export const TemperatureSensorDt = new DeviceTypeModel(definitions.TemperatureSensorDt);
+export const PressureSensorDt = new DeviceTypeModel(definitions.PressureSensorDt);
+export const FlowSensorDt = new DeviceTypeModel(definitions.FlowSensorDt);
+export const HumiditySensorDt = new DeviceTypeModel(definitions.HumiditySensorDt);
+export const OnOffSensorDt = new DeviceTypeModel(definitions.OnOffSensorDt);
+export const SmokeCoAlarmDt = new DeviceTypeModel(definitions.SmokeCoAlarmDt);
+export const AirQualitySensorDt = new DeviceTypeModel(definitions.AirQualitySensorDt);
+export const WaterFreezeDetectorDt = new DeviceTypeModel(definitions.WaterFreezeDetectorDt);
+export const WaterLeakDetectorDt = new DeviceTypeModel(definitions.WaterLeakDetectorDt);
+export const RainSensorDt = new DeviceTypeModel(definitions.RainSensorDt);
+export const DoorLockDt = new DeviceTypeModel(definitions.DoorLockDt);
+export const DoorLockControllerDt = new DeviceTypeModel(definitions.DoorLockControllerDt);
+export const WindowCoveringDt = new DeviceTypeModel(definitions.WindowCoveringDt);
+export const WindowCoveringControllerDt = new DeviceTypeModel(definitions.WindowCoveringControllerDt);
+export const ThermostatDt = new DeviceTypeModel(definitions.ThermostatDt);
+export const FanDt = new DeviceTypeModel(definitions.FanDt);
+export const AirPurifierDt = new DeviceTypeModel(definitions.AirPurifierDt);
+export const BasicVideoPlayerDt = new DeviceTypeModel(definitions.BasicVideoPlayerDt);
+export const CastingVideoPlayerDt = new DeviceTypeModel(definitions.CastingVideoPlayerDt);
+export const SpeakerDt = new DeviceTypeModel(definitions.SpeakerDt);
+export const ContentAppDt = new DeviceTypeModel(definitions.ContentAppDt);
+export const CastingVideoClientDt = new DeviceTypeModel(definitions.CastingVideoClientDt);
+export const VideoRemoteControlDt = new DeviceTypeModel(definitions.VideoRemoteControlDt);
+export const ModeSelectDt = new DeviceTypeModel(definitions.ModeSelectDt);
+export const AggregatorDt = new DeviceTypeModel(definitions.AggregatorDt);
+export const RoboticVacuumCleanerDt = new DeviceTypeModel(definitions.RoboticVacuumCleanerDt);
+export const LaundryWasherDt = new DeviceTypeModel(definitions.LaundryWasherDt);
+export const RefrigeratorDt = new DeviceTypeModel(definitions.RefrigeratorDt);
+export const RoomAirConditionerDt = new DeviceTypeModel(definitions.RoomAirConditionerDt);
+export const TemperatureControlledCabinetDt = new DeviceTypeModel(definitions.TemperatureControlledCabinetDt);
+export const DishwasherDt = new DeviceTypeModel(definitions.DishwasherDt);
+export const LaundryDryerDt = new DeviceTypeModel(definitions.LaundryDryerDt);
+export const CookSurfaceDt = new DeviceTypeModel(definitions.CookSurfaceDt);
+export const CooktopDt = new DeviceTypeModel(definitions.CooktopDt);
+export const OvenDt = new DeviceTypeModel(definitions.OvenDt);
+export const ExtractorHoodDt = new DeviceTypeModel(definitions.ExtractorHoodDt);
+export const MicrowaveOvenDt = new DeviceTypeModel(definitions.MicrowaveOvenDt);
+export const ClosureNs = new SemanticNamespaceModel(definitions.ClosureNs);
+export const CompassDirectionNs = new SemanticNamespaceModel(definitions.CompassDirectionNs);
+export const CompassLocationNs = new SemanticNamespaceModel(definitions.CompassLocationNs);
+export const DirectionNs = new SemanticNamespaceModel(definitions.DirectionNs);
+export const LevelNs = new SemanticNamespaceModel(definitions.LevelNs);
+export const LocationNs = new SemanticNamespaceModel(definitions.LocationNs);
+export const NumberNs = new SemanticNamespaceModel(definitions.NumberNs);
+export const PositionNs = new SemanticNamespaceModel(definitions.PositionNs);
+export const ElectricalMeasurementNs = new SemanticNamespaceModel(definitions.ElectricalMeasurementNs);
+export const LaundryNs = new SemanticNamespaceModel(definitions.LaundryNs);
+export const PowerSourceNs = new SemanticNamespaceModel(definitions.PowerSourceNs);
+export const RefrigeratorNs = new SemanticNamespaceModel(definitions.RefrigeratorNs);
+export const RoomAirConditionerNs = new SemanticNamespaceModel(definitions.RoomAirConditionerNs);
+export const SwitchesNs = new SemanticNamespaceModel(definitions.SwitchesNs);

package/src/standard/elements/namespace.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
+
+import { MatterDefinition } from "../MatterDefinition.js";
+import { DatatypeElement as Datatype } from "../../elements/index.js";
+
+export const namespace = Datatype({
+    name: "namespace", type: "uint8", description: "Namespace", isSeed: true,
+    details: "The Namespace type identifies the namespace used for a semantic tag.",
+    xref: { document: "core", section: "7.18.2.43" }
+})
+MatterDefinition.children.push(namespace);

package/src/standard/elements/node-id.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
+
+import { MatterDefinition } from "../MatterDefinition.js";
+import { DatatypeElement as Datatype } from "../../elements/index.js";
+
+export const nodeId = Datatype({
+    name: "node-id", type: "uint64", description: "Node ID", isSeed: true,
+    details: "A 64-bit ID for a node scoped and unique to a particular fabric as indicated by an accompanying " +
+        "fabric-index adjacent instantiation.",
+    xref: { document: "core", section: "7.18.2.21" }
+});
+
+MatterDefinition.children.push(nodeId);

package/src/standard/elements/octstr.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
+
+import { MatterDefinition } from "../MatterDefinition.js";
+import { DatatypeElement as Datatype } from "../../elements/index.js";
+
+export const octstr = Datatype({
+    name: "octstr", description: "Octet string", isSeed: true, metatype: "bytes",
+    details: "The octet string data type defines a sequence of octets with a finite octet count from 0 to 65534. " +
+        "It is recommended to define a constraint on the maximum possible count.",
+    xref: { document: "core", section: "7.18.1.7" }
+});
+
+MatterDefinition.children.push(octstr);

package/src/standard/elements/percent.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
+
+import { MatterDefinition } from "../MatterDefinition.js";
+import { DatatypeElement as Datatype } from "../../elements/index.js";
+
+export const percent = Datatype({
+    name: "percent", type: "uint8", description: "Percentage units 1%", isSeed: true,
+    xref: { document: "core", section: "7.18.2" }
+});
+MatterDefinition.children.push(percent);

package/src/standard/elements/percent100ths.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
+
+import { MatterDefinition } from "../MatterDefinition.js";
+import { DatatypeElement as Datatype } from "../../elements/index.js";
+
+export const percent100ths = Datatype({
+    name: "percent100ths", type: "uint16", description: "Percentage units 0.01%", isSeed: true,
+    xref: { document: "core", section: "7.18.2" }
+});
+MatterDefinition.children.push(percent100ths);

package/src/standard/elements/posix-ms.ts

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
+
+import { MatterDefinition } from "../MatterDefinition.js";
+import { DatatypeElement as Datatype } from "../../elements/index.js";
+
+export const posixMs = Datatype({
+    name: "posix-ms", type: "uint64", description: "POSIX Time in milliseconds", isSeed: true,
+    details: "This type represents an offset, in milliseconds, from the UNIX epoch (1970-01-01 00:00:00 UTC), " +
+        "encoded as an unsigned 64-bit scalar value." +
+        "\n" +
+        "This type is employed for compatibility reasons.",
+    xref: { document: "core", section: "7.18.2.7" }
+});
+
+MatterDefinition.children.push(posixMs);

package/src/standard/elements/power-mW.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
+
+import { MatterDefinition } from "../MatterDefinition.js";
+import { DatatypeElement as Datatype } from "../../elements/index.js";
+
+export const powerMW = Datatype({
+    name: "power-mW", type: "int64", description: "Power", isSeed: true,
+    details: "This type represents power measured in milliwatts.",
+    xref: { document: "core", section: "7.18.2.12" }
+});
+MatterDefinition.children.push(powerMW);

package/src/standard/elements/priority.ts

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
+
+import { MatterDefinition } from "../MatterDefinition.js";
+import { DatatypeElement as Datatype, FieldElement as Field } from "../../elements/index.js";
+
+export const priority = Datatype({
+    name: "priority", type: "enum8", description: "Priority", isSeed: true,
+    details: "This is an enumeration of priority used to tag events and possibly other data. The data type does " +
+        "not define any particular ordering among the values. Specific uses of the data type may assign " +
+        "semantics to the values that imply an ordering relationship.",
+    xref: { document: "core", section: "7.18.2.17" },
+
+    children: [
+        Field({ name: "Debug", id: 0x0, description: "Information for engineering debugging/troubleshooting" }),
+        Field({
+            name: "Info", id: 0x1,
+            description: "Information that either drives customer facing features or provides insights into device functions that are used to drive analytics use cases"
+        }),
+        Field({
+            name: "Critical", id: 0x2,
+            description: "Information or notification that impacts safety, a critical function, or ongoing reliable operation of the node or application supported on an endpoint."
+        })
+    ]
+});
+
+MatterDefinition.children.push(priority);