"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var models_exports = {};
__export(models_exports, {
  AcceptedCommandList: () => AcceptedCommandList,
  AccessControl: () => AccessControl,
  AccountLogin: () => AccountLogin,
  Actions: () => Actions,
  ActivatedCarbonFilterMonitoring: () => ActivatedCarbonFilterMonitoring,
  AdministratorCommissioning: () => AdministratorCommissioning,
  AggregatorDt: () => AggregatorDt,
  AirPurifierDt: () => AirPurifierDt,
  AirQuality: () => AirQuality,
  AirQualitySensorDt: () => AirQualitySensorDt,
  AlarmBase: () => AlarmBase,
  ApplicationBasic: () => ApplicationBasic,
  ApplicationLauncher: () => ApplicationLauncher,
  AttributeList: () => AttributeList,
  AudioOutput: () => AudioOutput,
  BallastConfiguration: () => BallastConfiguration,
  BaseDt: () => BaseDt,
  BasicInformation: () => BasicInformation,
  BasicVideoPlayerDt: () => BasicVideoPlayerDt,
  Binding: () => Binding,
  BooleanState: () => BooleanState,
  BooleanStateConfiguration: () => BooleanStateConfiguration,
  BridgedDeviceBasicInformation: () => BridgedDeviceBasicInformation,
  BridgedNodeDt: () => BridgedNodeDt,
  CarbonDioxideConcentrationMeasurement: () => CarbonDioxideConcentrationMeasurement,
  CarbonMonoxideConcentrationMeasurement: () => CarbonMonoxideConcentrationMeasurement,
  CastingVideoClientDt: () => CastingVideoClientDt,
  CastingVideoPlayerDt: () => CastingVideoPlayerDt,
  Channel: () => Channel,
  ClosureNs: () => ClosureNs,
  ClusterRevision: () => ClusterRevision,
  ColorControl: () => ColorControl,
  ColorDimmerSwitchDt: () => ColorDimmerSwitchDt,
  ColorTemperatureLightDt: () => ColorTemperatureLightDt,
  CompassDirectionNs: () => CompassDirectionNs,
  CompassLocationNs: () => CompassLocationNs,
  ConcentrationMeasurement: () => ConcentrationMeasurement,
  ContactSensorDt: () => ContactSensorDt,
  ContentAppDt: () => ContentAppDt,
  ContentAppObserver: () => ContentAppObserver,
  ContentControl: () => ContentControl,
  ContentLauncher: () => ContentLauncher,
  ControlBridgeDt: () => ControlBridgeDt,
  CookSurfaceDt: () => CookSurfaceDt,
  CooktopDt: () => CooktopDt,
  Descriptor: () => Descriptor,
  DeviceEnergyManagement: () => DeviceEnergyManagement,
  DeviceEnergyManagementDt: () => DeviceEnergyManagementDt,
  DeviceEnergyManagementMode: () => DeviceEnergyManagementMode,
  DiagnosticLogs: () => DiagnosticLogs,
  DimmableLightDt: () => DimmableLightDt,
  DimmablePlugInUnitDt: () => DimmablePlugInUnitDt,
  DimmerSwitchDt: () => DimmerSwitchDt,
  DirectionNs: () => DirectionNs,
  DishwasherAlarm: () => DishwasherAlarm,
  DishwasherDt: () => DishwasherDt,
  DishwasherMode: () => DishwasherMode,
  DoorLock: () => DoorLock,
  DoorLockControllerDt: () => DoorLockControllerDt,
  DoorLockDt: () => DoorLockDt,
  ElectricalEnergyMeasurement: () => ElectricalEnergyMeasurement,
  ElectricalMeasurementNs: () => ElectricalMeasurementNs,
  ElectricalPowerMeasurement: () => ElectricalPowerMeasurement,
  ElectricalSensorDt: () => ElectricalSensorDt,
  EnergyEvse: () => EnergyEvse,
  EnergyEvseMode: () => EnergyEvseMode,
  EnergyPreference: () => EnergyPreference,
  EthernetNetworkDiagnostics: () => EthernetNetworkDiagnostics,
  EventList: () => EventList,
  ExtendedColorLightDt: () => ExtendedColorLightDt,
  ExtractorHoodDt: () => ExtractorHoodDt,
  FabricIndex: () => FabricIndex,
  FanControl: () => FanControl,
  FanDt: () => FanDt,
  FeatureMap: () => FeatureMap,
  FixedLabel: () => FixedLabel,
  FlowMeasurement: () => FlowMeasurement,
  FlowSensorDt: () => FlowSensorDt,
  FormaldehydeConcentrationMeasurement: () => FormaldehydeConcentrationMeasurement,
  GeneralCommissioning: () => GeneralCommissioning,
  GeneralDiagnostics: () => GeneralDiagnostics,
  GeneratedCommandList: () => GeneratedCommandList,
  GenericSwitchDt: () => GenericSwitchDt,
  GroupKeyManagement: () => GroupKeyManagement,
  Groups: () => Groups,
  HepaFilterMonitoring: () => HepaFilterMonitoring,
  HumiditySensorDt: () => HumiditySensorDt,
  IcdManagement: () => IcdManagement,
  Identify: () => Identify,
  IlluminanceMeasurement: () => IlluminanceMeasurement,
  KeypadInput: () => KeypadInput,
  Label: () => Label,
  LaundryDryerControls: () => LaundryDryerControls,
  LaundryDryerDt: () => LaundryDryerDt,
  LaundryNs: () => LaundryNs,
  LaundryWasherControls: () => LaundryWasherControls,
  LaundryWasherDt: () => LaundryWasherDt,
  LaundryWasherMode: () => LaundryWasherMode,
  LevelControl: () => LevelControl,
  LevelNs: () => LevelNs,
  LightSensorDt: () => LightSensorDt,
  LocalizationConfiguration: () => LocalizationConfiguration,
  LocationNs: () => LocationNs,
  LowPower: () => LowPower,
  MeasurementAccuracyRangeStruct: () => MeasurementAccuracyRangeStruct,
  MeasurementAccuracyStruct: () => MeasurementAccuracyStruct,
  MeasurementTypeEnum: () => MeasurementTypeEnum,
  MediaInput: () => MediaInput,
  MediaPlayback: () => MediaPlayback,
  Messages: () => Messages,
  MicrowaveOvenControl: () => MicrowaveOvenControl,
  MicrowaveOvenDt: () => MicrowaveOvenDt,
  MicrowaveOvenMode: () => MicrowaveOvenMode,
  ModeBase: () => ModeBase,
  ModeSelect: () => ModeSelect,
  ModeSelectDt: () => ModeSelectDt,
  NetworkCommissioning: () => NetworkCommissioning,
  NitrogenDioxideConcentrationMeasurement: () => NitrogenDioxideConcentrationMeasurement,
  NumberNs: () => NumberNs,
  OccupancySensing: () => OccupancySensing,
  OccupancySensorDt: () => OccupancySensorDt,
  OnOff: () => OnOff,
  OnOffLightDt: () => OnOffLightDt,
  OnOffLightSwitchDt: () => OnOffLightSwitchDt,
  OnOffPlugInUnitDt: () => OnOffPlugInUnitDt,
  OnOffSensorDt: () => OnOffSensorDt,
  OperationalCredentials: () => OperationalCredentials,
  OperationalState: () => OperationalState,
  OtaProviderDt: () => OtaProviderDt,
  OtaRequestorDt: () => OtaRequestorDt,
  OtaSoftwareUpdateProvider: () => OtaSoftwareUpdateProvider,
  OtaSoftwareUpdateRequestor: () => OtaSoftwareUpdateRequestor,
  OvenCavityOperationalState: () => OvenCavityOperationalState,
  OvenDt: () => OvenDt,
  OvenMode: () => OvenMode,
  OzoneConcentrationMeasurement: () => OzoneConcentrationMeasurement,
  Pm10ConcentrationMeasurement: () => Pm10ConcentrationMeasurement,
  Pm1ConcentrationMeasurement: () => Pm1ConcentrationMeasurement,
  Pm25ConcentrationMeasurement: () => Pm25ConcentrationMeasurement,
  PositionNs: () => PositionNs,
  PowerSource: () => PowerSource,
  PowerSourceConfiguration: () => PowerSourceConfiguration,
  PowerSourceDt: () => PowerSourceDt,
  PowerSourceNs: () => PowerSourceNs,
  PowerTopology: () => PowerTopology,
  PressureMeasurement: () => PressureMeasurement,
  PressureSensorDt: () => PressureSensorDt,
  ProxyConfiguration: () => ProxyConfiguration,
  ProxyDiscovery: () => ProxyDiscovery,
  PulseWidthModulation: () => PulseWidthModulation,
  PumpConfigurationAndControl: () => PumpConfigurationAndControl,
  PumpControllerDt: () => PumpControllerDt,
  PumpDt: () => PumpDt,
  RadonConcentrationMeasurement: () => RadonConcentrationMeasurement,
  RainSensorDt: () => RainSensorDt,
  RefrigeratorAlarm: () => RefrigeratorAlarm,
  RefrigeratorAndTemperatureControlledCabinetMode: () => RefrigeratorAndTemperatureControlledCabinetMode,
  RefrigeratorDt: () => RefrigeratorDt,
  RefrigeratorNs: () => RefrigeratorNs,
  RelativeHumidityMeasurement: () => RelativeHumidityMeasurement,
  ResourceMonitoring: () => ResourceMonitoring,
  RoboticVacuumCleanerDt: () => RoboticVacuumCleanerDt,
  RoomAirConditionerDt: () => RoomAirConditionerDt,
  RoomAirConditionerNs: () => RoomAirConditionerNs,
  RootNodeDt: () => RootNodeDt,
  RvcCleanMode: () => RvcCleanMode,
  RvcOperationalState: () => RvcOperationalState,
  RvcRunMode: () => RvcRunMode,
  ScenesManagement: () => ScenesManagement,
  SmokeCoAlarm: () => SmokeCoAlarm,
  SmokeCoAlarmDt: () => SmokeCoAlarmDt,
  SoftwareDiagnostics: () => SoftwareDiagnostics,
  SoftwareVersionCertificationStatusEnum: () => SoftwareVersionCertificationStatusEnum,
  SpeakerDt: () => SpeakerDt,
  Switch: () => Switch,
  SwitchesNs: () => SwitchesNs,
  TargetNavigator: () => TargetNavigator,
  TemperatureControl: () => TemperatureControl,
  TemperatureControlledCabinetDt: () => TemperatureControlledCabinetDt,
  TemperatureMeasurement: () => TemperatureMeasurement,
  TemperatureSensorDt: () => TemperatureSensorDt,
  Thermostat: () => Thermostat,
  ThermostatDt: () => ThermostatDt,
  ThermostatUserInterfaceConfiguration: () => ThermostatUserInterfaceConfiguration,
  ThreadNetworkDiagnostics: () => ThreadNetworkDiagnostics,
  TimeFormatLocalization: () => TimeFormatLocalization,
  TimeSynchronization: () => TimeSynchronization,
  TotalVolatileOrganicCompoundsConcentrationMeasurement: () => TotalVolatileOrganicCompoundsConcentrationMeasurement,
  UnitLocalization: () => UnitLocalization,
  UserLabel: () => UserLabel,
  ValidProxies: () => ValidProxies,
  ValveConfigurationAndControl: () => ValveConfigurationAndControl,
  VideoRemoteControlDt: () => VideoRemoteControlDt,
  WakeOnLan: () => WakeOnLan,
  WaterFreezeDetectorDt: () => WaterFreezeDetectorDt,
  WaterLeakDetectorDt: () => WaterLeakDetectorDt,
  WaterValveDt: () => WaterValveDt,
  WiFiNetworkDiagnostics: () => WiFiNetworkDiagnostics,
  WildcardPathFlagsBitmap: () => WildcardPathFlagsBitmap,
  WindowCovering: () => WindowCovering,
  WindowCoveringControllerDt: () => WindowCoveringControllerDt,
  WindowCoveringDt: () => WindowCoveringDt,
  actionId: () => actionId,
  amperageMA: () => amperageMA,
  any: () => any,
  attribId: () => attribId,
  bool: () => bool,
  clusterId: () => clusterId,
  commandId: () => commandId,
  dataVer: () => dataVer,
  date: () => date,
  devtypeId: () => devtypeId,
  double: () => double,
  elapsedS: () => elapsedS,
  endpointNo: () => endpointNo,
  energyMWh: () => energyMWh,
  entryIdx: () => entryIdx,
  enum16: () => enum16,
  enum8: () => enum8,
  epochS: () => epochS,
  epochUs: () => epochUs,
  eventId: () => eventId,
  eventNo: () => eventNo,
  fabricId: () => fabricId,
  fabricIdx: () => fabricIdx,
  fieldId: () => fieldId,
  groupId: () => groupId,
  hwadr: () => hwadr,
  int16: () => int16,
  int24: () => int24,
  int32: () => int32,
  int40: () => int40,
  int48: () => int48,
  int56: () => int56,
  int64: () => int64,
  int8: () => int8,
  ipadr: () => ipadr,
  ipv4Adr: () => ipv4Adr,
  ipv6Adr: () => ipv6Adr,
  ipv6Pre: () => ipv6Pre,
  list: () => list,
  map16: () => map16,
  map32: () => map32,
  map64: () => map64,
  map8: () => map8,
  namespace: () => namespace,
  nodeId: () => nodeId,
  octstr: () => octstr,
  percent: () => percent,
  percent100ths: () => percent100ths,
  posixMs: () => posixMs,
  powerMW: () => powerMW,
  priority: () => priority,
  semtag: () => semtag,
  single: () => single,
  status: () => status,
  string: () => string,
  struct: () => struct,
  subjectId: () => subjectId,
  systimeMs: () => systimeMs,
  systimeUs: () => systimeUs,
  tag: () => tag,
  temperature: () => temperature,
  tod: () => tod,
  transId: () => transId,
  uint16: () => uint16,
  uint24: () => uint24,
  uint32: () => uint32,
  uint40: () => uint40,
  uint48: () => uint48,
  uint56: () => uint56,
  uint64: () => uint64,
  uint8: () => uint8,
  vendorId: () => vendorId,
  voltageMV: () => voltageMV
});
module.exports = __toCommonJS(models_exports);
var definitions = __toESM(require("./definitions.js"), 1);
var import_ClusterModel = require("../../models/ClusterModel.js");
var import_DatatypeModel = require("../../models/DatatypeModel.js");
var import_AttributeModel = require("../../models/AttributeModel.js");
var import_FieldModel = require("../../models/FieldModel.js");
var import_DeviceTypeModel = require("../../models/DeviceTypeModel.js");
var import_SemanticNamespaceModel = require("../../models/SemanticNamespaceModel.js");
/**
 * @license
 * Copyright 2022-2025 Matter.js Authors
 * SPDX-License-Identifier: Apache-2.0
 */
const Identify = new import_ClusterModel.ClusterModel(definitions.Identify);
const Groups = new import_ClusterModel.ClusterModel(definitions.Groups);
const ScenesManagement = new import_ClusterModel.ClusterModel(definitions.ScenesManagement);
const OnOff = new import_ClusterModel.ClusterModel(definitions.OnOff);
const LevelControl = new import_ClusterModel.ClusterModel(definitions.LevelControl);
const PulseWidthModulation = new import_ClusterModel.ClusterModel(definitions.PulseWidthModulation);
const BooleanState = new import_ClusterModel.ClusterModel(definitions.BooleanState);
const BooleanStateConfiguration = new import_ClusterModel.ClusterModel(definitions.BooleanStateConfiguration);
const ModeSelect = new import_ClusterModel.ClusterModel(definitions.ModeSelect);
const ModeBase = new import_ClusterModel.ClusterModel(definitions.ModeBase);
const LowPower = new import_ClusterModel.ClusterModel(definitions.LowPower);
const WakeOnLan = new import_ClusterModel.ClusterModel(definitions.WakeOnLan);
const Switch = new import_ClusterModel.ClusterModel(definitions.Switch);
const OperationalState = new import_ClusterModel.ClusterModel(definitions.OperationalState);
const AlarmBase = new import_ClusterModel.ClusterModel(definitions.AlarmBase);
const Messages = new import_ClusterModel.ClusterModel(definitions.Messages);
const IlluminanceMeasurement = new import_ClusterModel.ClusterModel(definitions.IlluminanceMeasurement);
const TemperatureMeasurement = new import_ClusterModel.ClusterModel(definitions.TemperatureMeasurement);
const PressureMeasurement = new import_ClusterModel.ClusterModel(definitions.PressureMeasurement);
const FlowMeasurement = new import_ClusterModel.ClusterModel(definitions.FlowMeasurement);
const RelativeHumidityMeasurement = new import_ClusterModel.ClusterModel(definitions.RelativeHumidityMeasurement);
const OccupancySensing = new import_ClusterModel.ClusterModel(definitions.OccupancySensing);
const ResourceMonitoring = new import_ClusterModel.ClusterModel(definitions.ResourceMonitoring);
const HepaFilterMonitoring = new import_ClusterModel.ClusterModel(definitions.HepaFilterMonitoring);
const ActivatedCarbonFilterMonitoring = new import_ClusterModel.ClusterModel(definitions.ActivatedCarbonFilterMonitoring);
const AirQuality = new import_ClusterModel.ClusterModel(definitions.AirQuality);
const ConcentrationMeasurement = new import_ClusterModel.ClusterModel(definitions.ConcentrationMeasurement);
const CarbonMonoxideConcentrationMeasurement = new import_ClusterModel.ClusterModel(definitions.CarbonMonoxideConcentrationMeasurement);
const CarbonDioxideConcentrationMeasurement = new import_ClusterModel.ClusterModel(definitions.CarbonDioxideConcentrationMeasurement);
const NitrogenDioxideConcentrationMeasurement = new import_ClusterModel.ClusterModel(definitions.NitrogenDioxideConcentrationMeasurement);
const OzoneConcentrationMeasurement = new import_ClusterModel.ClusterModel(definitions.OzoneConcentrationMeasurement);
const Pm25ConcentrationMeasurement = new import_ClusterModel.ClusterModel(definitions.Pm25ConcentrationMeasurement);
const FormaldehydeConcentrationMeasurement = new import_ClusterModel.ClusterModel(definitions.FormaldehydeConcentrationMeasurement);
const Pm1ConcentrationMeasurement = new import_ClusterModel.ClusterModel(definitions.Pm1ConcentrationMeasurement);
const Pm10ConcentrationMeasurement = new import_ClusterModel.ClusterModel(definitions.Pm10ConcentrationMeasurement);
const TotalVolatileOrganicCompoundsConcentrationMeasurement = new import_ClusterModel.ClusterModel(definitions.TotalVolatileOrganicCompoundsConcentrationMeasurement);
const RadonConcentrationMeasurement = new import_ClusterModel.ClusterModel(definitions.RadonConcentrationMeasurement);
const SmokeCoAlarm = new import_ClusterModel.ClusterModel(definitions.SmokeCoAlarm);
const ElectricalEnergyMeasurement = new import_ClusterModel.ClusterModel(definitions.ElectricalEnergyMeasurement);
const ElectricalPowerMeasurement = new import_ClusterModel.ClusterModel(definitions.ElectricalPowerMeasurement);
const ColorControl = new import_ClusterModel.ClusterModel(definitions.ColorControl);
const BallastConfiguration = new import_ClusterModel.ClusterModel(definitions.BallastConfiguration);
const PumpConfigurationAndControl = new import_ClusterModel.ClusterModel(definitions.PumpConfigurationAndControl);
const Thermostat = new import_ClusterModel.ClusterModel(definitions.Thermostat);
const FanControl = new import_ClusterModel.ClusterModel(definitions.FanControl);
const ThermostatUserInterfaceConfiguration = new import_ClusterModel.ClusterModel(definitions.ThermostatUserInterfaceConfiguration);
const ValveConfigurationAndControl = new import_ClusterModel.ClusterModel(definitions.ValveConfigurationAndControl);
const DoorLock = new import_ClusterModel.ClusterModel(definitions.DoorLock);
const WindowCovering = new import_ClusterModel.ClusterModel(definitions.WindowCovering);
const AccountLogin = new import_ClusterModel.ClusterModel(definitions.AccountLogin);
const ApplicationBasic = new import_ClusterModel.ClusterModel(definitions.ApplicationBasic);
const ApplicationLauncher = new import_ClusterModel.ClusterModel(definitions.ApplicationLauncher);
const AudioOutput = new import_ClusterModel.ClusterModel(definitions.AudioOutput);
const Channel = new import_ClusterModel.ClusterModel(definitions.Channel);
const ContentLauncher = new import_ClusterModel.ClusterModel(definitions.ContentLauncher);
const KeypadInput = new import_ClusterModel.ClusterModel(definitions.KeypadInput);
const MediaInput = new import_ClusterModel.ClusterModel(definitions.MediaInput);
const MediaPlayback = new import_ClusterModel.ClusterModel(definitions.MediaPlayback);
const TargetNavigator = new import_ClusterModel.ClusterModel(definitions.TargetNavigator);
const ContentAppObserver = new import_ClusterModel.ClusterModel(definitions.ContentAppObserver);
const ContentControl = new import_ClusterModel.ClusterModel(definitions.ContentControl);
const RvcRunMode = new import_ClusterModel.ClusterModel(definitions.RvcRunMode);
const RvcCleanMode = new import_ClusterModel.ClusterModel(definitions.RvcCleanMode);
const RvcOperationalState = new import_ClusterModel.ClusterModel(definitions.RvcOperationalState);
const TemperatureControl = new import_ClusterModel.ClusterModel(definitions.TemperatureControl);
const DishwasherMode = new import_ClusterModel.ClusterModel(definitions.DishwasherMode);
const DishwasherAlarm = new import_ClusterModel.ClusterModel(definitions.DishwasherAlarm);
const LaundryWasherMode = new import_ClusterModel.ClusterModel(definitions.LaundryWasherMode);
const LaundryWasherControls = new import_ClusterModel.ClusterModel(definitions.LaundryWasherControls);
const RefrigeratorAndTemperatureControlledCabinetMode = new import_ClusterModel.ClusterModel(definitions.RefrigeratorAndTemperatureControlledCabinetMode);
const RefrigeratorAlarm = new import_ClusterModel.ClusterModel(definitions.RefrigeratorAlarm);
const LaundryDryerControls = new import_ClusterModel.ClusterModel(definitions.LaundryDryerControls);
const OvenCavityOperationalState = new import_ClusterModel.ClusterModel(definitions.OvenCavityOperationalState);
const OvenMode = new import_ClusterModel.ClusterModel(definitions.OvenMode);
const MicrowaveOvenMode = new import_ClusterModel.ClusterModel(definitions.MicrowaveOvenMode);
const MicrowaveOvenControl = new import_ClusterModel.ClusterModel(definitions.MicrowaveOvenControl);
const DeviceEnergyManagement = new import_ClusterModel.ClusterModel(definitions.DeviceEnergyManagement);
const EnergyEvse = new import_ClusterModel.ClusterModel(definitions.EnergyEvse);
const EnergyEvseMode = new import_ClusterModel.ClusterModel(definitions.EnergyEvseMode);
const EnergyPreference = new import_ClusterModel.ClusterModel(definitions.EnergyPreference);
const DeviceEnergyManagementMode = new import_ClusterModel.ClusterModel(definitions.DeviceEnergyManagementMode);
const Descriptor = new import_ClusterModel.ClusterModel(definitions.Descriptor);
const Binding = new import_ClusterModel.ClusterModel(definitions.Binding);
const Label = new import_ClusterModel.ClusterModel(definitions.Label);
const FixedLabel = new import_ClusterModel.ClusterModel(definitions.FixedLabel);
const UserLabel = new import_ClusterModel.ClusterModel(definitions.UserLabel);
const AccessControl = new import_ClusterModel.ClusterModel(definitions.AccessControl);
const BridgedDeviceBasicInformation = new import_ClusterModel.ClusterModel(definitions.BridgedDeviceBasicInformation);
const Actions = new import_ClusterModel.ClusterModel(definitions.Actions);
const ProxyDiscovery = new import_ClusterModel.ClusterModel(definitions.ProxyDiscovery);
const ProxyConfiguration = new import_ClusterModel.ClusterModel(definitions.ProxyConfiguration);
const ValidProxies = new import_ClusterModel.ClusterModel(definitions.ValidProxies);
const IcdManagement = new import_ClusterModel.ClusterModel(definitions.IcdManagement);
const BasicInformation = new import_ClusterModel.ClusterModel(definitions.BasicInformation);
const GroupKeyManagement = new import_ClusterModel.ClusterModel(definitions.GroupKeyManagement);
const LocalizationConfiguration = new import_ClusterModel.ClusterModel(definitions.LocalizationConfiguration);
const TimeFormatLocalization = new import_ClusterModel.ClusterModel(definitions.TimeFormatLocalization);
const UnitLocalization = new import_ClusterModel.ClusterModel(definitions.UnitLocalization);
const PowerSourceConfiguration = new import_ClusterModel.ClusterModel(definitions.PowerSourceConfiguration);
const PowerSource = new import_ClusterModel.ClusterModel(definitions.PowerSource);
const PowerTopology = new import_ClusterModel.ClusterModel(definitions.PowerTopology);
const NetworkCommissioning = new import_ClusterModel.ClusterModel(definitions.NetworkCommissioning);
const GeneralCommissioning = new import_ClusterModel.ClusterModel(definitions.GeneralCommissioning);
const DiagnosticLogs = new import_ClusterModel.ClusterModel(definitions.DiagnosticLogs);
const GeneralDiagnostics = new import_ClusterModel.ClusterModel(definitions.GeneralDiagnostics);
const SoftwareDiagnostics = new import_ClusterModel.ClusterModel(definitions.SoftwareDiagnostics);
const ThreadNetworkDiagnostics = new import_ClusterModel.ClusterModel(definitions.ThreadNetworkDiagnostics);
const WiFiNetworkDiagnostics = new import_ClusterModel.ClusterModel(definitions.WiFiNetworkDiagnostics);
const EthernetNetworkDiagnostics = new import_ClusterModel.ClusterModel(definitions.EthernetNetworkDiagnostics);
const TimeSynchronization = new import_ClusterModel.ClusterModel(definitions.TimeSynchronization);
const OperationalCredentials = new import_ClusterModel.ClusterModel(definitions.OperationalCredentials);
const AdministratorCommissioning = new import_ClusterModel.ClusterModel(definitions.AdministratorCommissioning);
const OtaSoftwareUpdateProvider = new import_ClusterModel.ClusterModel(definitions.OtaSoftwareUpdateProvider);
const OtaSoftwareUpdateRequestor = new import_ClusterModel.ClusterModel(definitions.OtaSoftwareUpdateRequestor);
const MeasurementTypeEnum = new import_DatatypeModel.DatatypeModel(definitions.MeasurementTypeEnum);
const MeasurementAccuracyRangeStruct = new import_DatatypeModel.DatatypeModel(definitions.MeasurementAccuracyRangeStruct);
const MeasurementAccuracyStruct = new import_DatatypeModel.DatatypeModel(definitions.MeasurementAccuracyStruct);
const bool = new import_DatatypeModel.DatatypeModel(definitions.bool);
const map8 = new import_DatatypeModel.DatatypeModel(definitions.map8);
const map16 = new import_DatatypeModel.DatatypeModel(definitions.map16);
const map32 = new import_DatatypeModel.DatatypeModel(definitions.map32);
const map64 = new import_DatatypeModel.DatatypeModel(definitions.map64);
const uint8 = new import_DatatypeModel.DatatypeModel(definitions.uint8);
const uint16 = new import_DatatypeModel.DatatypeModel(definitions.uint16);
const uint24 = new import_DatatypeModel.DatatypeModel(definitions.uint24);
const uint32 = new import_DatatypeModel.DatatypeModel(definitions.uint32);
const uint40 = new import_DatatypeModel.DatatypeModel(definitions.uint40);
const uint48 = new import_DatatypeModel.DatatypeModel(definitions.uint48);
const uint56 = new import_DatatypeModel.DatatypeModel(definitions.uint56);
const uint64 = new import_DatatypeModel.DatatypeModel(definitions.uint64);
const int8 = new import_DatatypeModel.DatatypeModel(definitions.int8);
const int16 = new import_DatatypeModel.DatatypeModel(definitions.int16);
const int24 = new import_DatatypeModel.DatatypeModel(definitions.int24);
const int32 = new import_DatatypeModel.DatatypeModel(definitions.int32);
const int40 = new import_DatatypeModel.DatatypeModel(definitions.int40);
const int48 = new import_DatatypeModel.DatatypeModel(definitions.int48);
const int56 = new import_DatatypeModel.DatatypeModel(definitions.int56);
const int64 = new import_DatatypeModel.DatatypeModel(definitions.int64);
const single = new import_DatatypeModel.DatatypeModel(definitions.single);
const double = new import_DatatypeModel.DatatypeModel(definitions.double);
const octstr = new import_DatatypeModel.DatatypeModel(definitions.octstr);
const list = new import_DatatypeModel.DatatypeModel(definitions.list);
const struct = new import_DatatypeModel.DatatypeModel(definitions.struct);
const percent = new import_DatatypeModel.DatatypeModel(definitions.percent);
const percent100ths = new import_DatatypeModel.DatatypeModel(definitions.percent100ths);
const tod = new import_DatatypeModel.DatatypeModel(definitions.tod);
const date = new import_DatatypeModel.DatatypeModel(definitions.date);
const epochUs = new import_DatatypeModel.DatatypeModel(definitions.epochUs);
const epochS = new import_DatatypeModel.DatatypeModel(definitions.epochS);
const posixMs = new import_DatatypeModel.DatatypeModel(definitions.posixMs);
const systimeUs = new import_DatatypeModel.DatatypeModel(definitions.systimeUs);
const systimeMs = new import_DatatypeModel.DatatypeModel(definitions.systimeMs);
const elapsedS = new import_DatatypeModel.DatatypeModel(definitions.elapsedS);
const temperature = new import_DatatypeModel.DatatypeModel(definitions.temperature);
const powerMW = new import_DatatypeModel.DatatypeModel(definitions.powerMW);
const amperageMA = new import_DatatypeModel.DatatypeModel(definitions.amperageMA);
const voltageMV = new import_DatatypeModel.DatatypeModel(definitions.voltageMV);
const energyMWh = new import_DatatypeModel.DatatypeModel(definitions.energyMWh);
const enum8 = new import_DatatypeModel.DatatypeModel(definitions.enum8);
const enum16 = new import_DatatypeModel.DatatypeModel(definitions.enum16);
const priority = new import_DatatypeModel.DatatypeModel(definitions.priority);
const status = new import_DatatypeModel.DatatypeModel(definitions.status);
const groupId = new import_DatatypeModel.DatatypeModel(definitions.groupId);
const endpointNo = new import_DatatypeModel.DatatypeModel(definitions.endpointNo);
const vendorId = new import_DatatypeModel.DatatypeModel(definitions.vendorId);
const devtypeId = new import_DatatypeModel.DatatypeModel(definitions.devtypeId);
const fabricId = new import_DatatypeModel.DatatypeModel(definitions.fabricId);
const fabricIdx = new import_DatatypeModel.DatatypeModel(definitions.fabricIdx);
const clusterId = new import_DatatypeModel.DatatypeModel(definitions.clusterId);
const attribId = new import_DatatypeModel.DatatypeModel(definitions.attribId);
const fieldId = new import_DatatypeModel.DatatypeModel(definitions.fieldId);
const eventId = new import_DatatypeModel.DatatypeModel(definitions.eventId);
const commandId = new import_DatatypeModel.DatatypeModel(definitions.commandId);
const actionId = new import_DatatypeModel.DatatypeModel(definitions.actionId);
const transId = new import_DatatypeModel.DatatypeModel(definitions.transId);
const nodeId = new import_DatatypeModel.DatatypeModel(definitions.nodeId);
const entryIdx = new import_DatatypeModel.DatatypeModel(definitions.entryIdx);
const dataVer = new import_DatatypeModel.DatatypeModel(definitions.dataVer);
const eventNo = new import_DatatypeModel.DatatypeModel(definitions.eventNo);
const string = new import_DatatypeModel.DatatypeModel(definitions.string);
const ipadr = new import_DatatypeModel.DatatypeModel(definitions.ipadr);
const ipv4Adr = new import_DatatypeModel.DatatypeModel(definitions.ipv4Adr);
const ipv6Adr = new import_DatatypeModel.DatatypeModel(definitions.ipv6Adr);
const ipv6Pre = new import_DatatypeModel.DatatypeModel(definitions.ipv6Pre);
const hwadr = new import_DatatypeModel.DatatypeModel(definitions.hwadr);
const semtag = new import_DatatypeModel.DatatypeModel(definitions.semtag);
const namespace = new import_DatatypeModel.DatatypeModel(definitions.namespace);
const tag = new import_DatatypeModel.DatatypeModel(definitions.tag);
const WildcardPathFlagsBitmap = new import_DatatypeModel.DatatypeModel(definitions.WildcardPathFlagsBitmap);
const SoftwareVersionCertificationStatusEnum = new import_DatatypeModel.DatatypeModel(definitions.SoftwareVersionCertificationStatusEnum);
const any = new import_DatatypeModel.DatatypeModel(definitions.any);
const subjectId = new import_DatatypeModel.DatatypeModel(definitions.subjectId);
const ClusterRevision = new import_AttributeModel.AttributeModel(definitions.ClusterRevision);
const FeatureMap = new import_AttributeModel.AttributeModel(definitions.FeatureMap);
const AttributeList = new import_AttributeModel.AttributeModel(definitions.AttributeList);
const EventList = new import_AttributeModel.AttributeModel(definitions.EventList);
const AcceptedCommandList = new import_AttributeModel.AttributeModel(definitions.AcceptedCommandList);
const GeneratedCommandList = new import_AttributeModel.AttributeModel(definitions.GeneratedCommandList);
const FabricIndex = new import_FieldModel.FieldModel(definitions.FabricIndex);
const BaseDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.BaseDt);
const RootNodeDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.RootNodeDt);
const PowerSourceDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.PowerSourceDt);
const OtaRequestorDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.OtaRequestorDt);
const OtaProviderDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.OtaProviderDt);
const BridgedNodeDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.BridgedNodeDt);
const ElectricalSensorDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.ElectricalSensorDt);
const DeviceEnergyManagementDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.DeviceEnergyManagementDt);
const OnOffLightDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.OnOffLightDt);
const DimmableLightDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.DimmableLightDt);
const ColorTemperatureLightDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.ColorTemperatureLightDt);
const ExtendedColorLightDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.ExtendedColorLightDt);
const OnOffPlugInUnitDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.OnOffPlugInUnitDt);
const DimmablePlugInUnitDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.DimmablePlugInUnitDt);
const PumpDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.PumpDt);
const WaterValveDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.WaterValveDt);
const OnOffLightSwitchDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.OnOffLightSwitchDt);
const DimmerSwitchDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.DimmerSwitchDt);
const ColorDimmerSwitchDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.ColorDimmerSwitchDt);
const ControlBridgeDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.ControlBridgeDt);
const PumpControllerDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.PumpControllerDt);
const GenericSwitchDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.GenericSwitchDt);
const ContactSensorDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.ContactSensorDt);
const LightSensorDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.LightSensorDt);
const OccupancySensorDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.OccupancySensorDt);
const TemperatureSensorDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.TemperatureSensorDt);
const PressureSensorDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.PressureSensorDt);
const FlowSensorDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.FlowSensorDt);
const HumiditySensorDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.HumiditySensorDt);
const OnOffSensorDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.OnOffSensorDt);
const SmokeCoAlarmDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.SmokeCoAlarmDt);
const AirQualitySensorDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.AirQualitySensorDt);
const WaterFreezeDetectorDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.WaterFreezeDetectorDt);
const WaterLeakDetectorDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.WaterLeakDetectorDt);
const RainSensorDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.RainSensorDt);
const DoorLockDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.DoorLockDt);
const DoorLockControllerDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.DoorLockControllerDt);
const WindowCoveringDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.WindowCoveringDt);
const WindowCoveringControllerDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.WindowCoveringControllerDt);
const ThermostatDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.ThermostatDt);
const FanDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.FanDt);
const AirPurifierDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.AirPurifierDt);
const BasicVideoPlayerDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.BasicVideoPlayerDt);
const CastingVideoPlayerDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.CastingVideoPlayerDt);
const SpeakerDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.SpeakerDt);
const ContentAppDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.ContentAppDt);
const CastingVideoClientDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.CastingVideoClientDt);
const VideoRemoteControlDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.VideoRemoteControlDt);
const ModeSelectDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.ModeSelectDt);
const AggregatorDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.AggregatorDt);
const RoboticVacuumCleanerDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.RoboticVacuumCleanerDt);
const LaundryWasherDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.LaundryWasherDt);
const RefrigeratorDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.RefrigeratorDt);
const RoomAirConditionerDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.RoomAirConditionerDt);
const TemperatureControlledCabinetDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.TemperatureControlledCabinetDt);
const DishwasherDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.DishwasherDt);
const LaundryDryerDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.LaundryDryerDt);
const CookSurfaceDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.CookSurfaceDt);
const CooktopDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.CooktopDt);
const OvenDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.OvenDt);
const ExtractorHoodDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.ExtractorHoodDt);
const MicrowaveOvenDt = new import_DeviceTypeModel.DeviceTypeModel(definitions.MicrowaveOvenDt);
const ClosureNs = new import_SemanticNamespaceModel.SemanticNamespaceModel(definitions.ClosureNs);
const CompassDirectionNs = new import_SemanticNamespaceModel.SemanticNamespaceModel(definitions.CompassDirectionNs);
const CompassLocationNs = new import_SemanticNamespaceModel.SemanticNamespaceModel(definitions.CompassLocationNs);
const DirectionNs = new import_SemanticNamespaceModel.SemanticNamespaceModel(definitions.DirectionNs);
const LevelNs = new import_SemanticNamespaceModel.SemanticNamespaceModel(definitions.LevelNs);
const LocationNs = new import_SemanticNamespaceModel.SemanticNamespaceModel(definitions.LocationNs);
const NumberNs = new import_SemanticNamespaceModel.SemanticNamespaceModel(definitions.NumberNs);
const PositionNs = new import_SemanticNamespaceModel.SemanticNamespaceModel(definitions.PositionNs);
const ElectricalMeasurementNs = new import_SemanticNamespaceModel.SemanticNamespaceModel(definitions.ElectricalMeasurementNs);
const LaundryNs = new import_SemanticNamespaceModel.SemanticNamespaceModel(definitions.LaundryNs);
const PowerSourceNs = new import_SemanticNamespaceModel.SemanticNamespaceModel(definitions.PowerSourceNs);
const RefrigeratorNs = new import_SemanticNamespaceModel.SemanticNamespaceModel(definitions.RefrigeratorNs);
const RoomAirConditionerNs = new import_SemanticNamespaceModel.SemanticNamespaceModel(definitions.RoomAirConditionerNs);
const SwitchesNs = new import_SemanticNamespaceModel.SemanticNamespaceModel(definitions.SwitchesNs);
//# sourceMappingURL=models.js.map
