zzz_generated/app-common/app-common/zap-generated/cluster-enums.h - third_party/github/project-chip/connectedhomeip - Git at Google

 /*
  *
  *    Copyright (c) 2022 Project CHIP Authors
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
  *    You may obtain a copy of the License at
  *
  *        http://www.apache.org/licenses/LICENSE-2.0
  *
  *    Unless required by applicable law or agreed to in writing, software
  *    distributed under the License is distributed on an "AS IS" BASIS,
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */

 // THIS FILE IS GENERATED BY ZAP

 #pragma once

 #include <stdint.h>

 #include <app-common/zap-generated/enums.h>

 namespace chip {
 namespace app {
 namespace Clusters {

 namespace Identify {

 // Enum for EffectIdentifierEnum
 enum class EffectIdentifierEnum : uint8_t
 {
     kBlink         = 0x00,
     kBreathe       = 0x01,
     kOkay          = 0x02,
     kChannelChange = 0x0B,
     kFinishEffect  = 0xFE,
     kStopEffect    = 0xFF,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for EffectVariantEnum
 enum class EffectVariantEnum : uint8_t
 {
     kDefault = 0x00,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 1,
 };

 // Enum for IdentifyTypeEnum
 enum class IdentifyTypeEnum : uint8_t
 {
     kNone             = 0x00,
     kLightOutput      = 0x01,
     kVisibleIndicator = 0x02,
     kAudibleBeep      = 0x03,
     kDisplay          = 0x04,
     kActuator         = 0x05,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 6,
 };
 } // namespace Identify

 namespace Groups {

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kGroupNames = 0x1,
 };

 // Bitmap for NameSupportBitmap
 enum class NameSupportBitmap : uint8_t
 {
     kGroupNames = 0x80,
 };
 } // namespace Groups

 namespace Scenes {

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kSceneNames = 0x1,
 };

 // Bitmap for ScenesCopyMode
 enum class ScenesCopyMode : uint8_t
 {
     kCopyAllScenes = 0x1,
 };
 } // namespace Scenes

 namespace OnOff {

 // Enum for OnOffDelayedAllOffEffectVariant
 enum class OnOffDelayedAllOffEffectVariant : uint8_t
 {
     kFadeToOffIn0p8Seconds                                = 0x00,
     kNoFade                                               = 0x01,
     k50PercentDimDownIn0p8SecondsThenFadeToOffIn12Seconds = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for OnOffDyingLightEffectVariant
 enum class OnOffDyingLightEffectVariant : uint8_t
 {
     k20PercenterDimUpIn0p5SecondsThenFadeToOffIn1Second = 0x00,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 1,
 };

 // Enum for OnOffEffectIdentifier
 enum class OnOffEffectIdentifier : uint8_t
 {
     kDelayedAllOff = 0x00,
     kDyingLight    = 0x01,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };

 // Enum for OnOffStartUpOnOff
 enum class OnOffStartUpOnOff : uint8_t
 {
     kOff                 = 0x00,
     kOn                  = 0x01,
     kTogglePreviousOnOff = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kLighting  = 0x1,
     kDeadFront = 0x2,
 };

 // Bitmap for OnOffControl
 enum class OnOffControl : uint8_t
 {
     kAcceptOnlyWhenOn = 0x1,
 };
 } // namespace OnOff

 namespace OnOffSwitchConfiguration {} // namespace OnOffSwitchConfiguration

 namespace LevelControl {

 // Need to convert consumers to using the new enum classes, so we
 // don't just have casts all over.
 #ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
 // Enum for MoveMode
 enum class MoveMode : uint8_t
 {
     kUp   = 0x00,
     kDown = 0x01,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };
 #else  // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
 using MoveMode                                                     = EmberAfMoveMode;
 static MoveMode __attribute__((unused)) kMoveModekUnknownEnumValue = static_cast<MoveMode>(2);
 #endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM

 // Need to convert consumers to using the new enum classes, so we
 // don't just have casts all over.
 #ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
 // Enum for StepMode
 enum class StepMode : uint8_t
 {
     kUp   = 0x00,
     kDown = 0x01,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };
 #else  // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
 using StepMode                                                     = EmberAfStepMode;
 static StepMode __attribute__((unused)) kStepModekUnknownEnumValue = static_cast<StepMode>(2);
 #endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kOnOff     = 0x1,
     kLighting  = 0x2,
     kFrequency = 0x4,
 };

 // Bitmap for LevelControlOptions
 enum class LevelControlOptions : uint8_t
 {
     kExecuteIfOff           = 0x1,
     kCoupleColorTempToLevel = 0x2,
 };
 } // namespace LevelControl

 namespace BinaryInputBasic {} // namespace BinaryInputBasic

 namespace PulseWidthModulation {} // namespace PulseWidthModulation

 namespace Descriptor {} // namespace Descriptor

 namespace Binding {} // namespace Binding

 namespace AccessControl {

 // Enum for AccessControlEntryAuthModeEnum
 enum class AccessControlEntryAuthModeEnum : uint8_t
 {
     kPase  = 0x01,
     kCase  = 0x02,
     kGroup = 0x03,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 0,
 };

 // Enum for AccessControlEntryPrivilegeEnum
 enum class AccessControlEntryPrivilegeEnum : uint8_t
 {
     kView       = 0x01,
     kProxyView  = 0x02,
     kOperate    = 0x03,
     kManage     = 0x04,
     kAdminister = 0x05,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 0,
 };

 // Enum for ChangeTypeEnum
 enum class ChangeTypeEnum : uint8_t
 {
     kChanged = 0x00,
     kAdded   = 0x01,
     kRemoved = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };
 } // namespace AccessControl

 namespace Actions {

 // Enum for ActionErrorEnum
 enum class ActionErrorEnum : uint8_t
 {
     kUnknown     = 0x00,
     kInterrupted = 0x01,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };

 // Enum for ActionStateEnum
 enum class ActionStateEnum : uint8_t
 {
     kInactive = 0x00,
     kActive   = 0x01,
     kPaused   = 0x02,
     kDisabled = 0x03,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 4,
 };

 // Enum for ActionTypeEnum
 enum class ActionTypeEnum : uint8_t
 {
     kOther        = 0x00,
     kScene        = 0x01,
     kSequence     = 0x02,
     kAutomation   = 0x03,
     kException    = 0x04,
     kNotification = 0x05,
     kAlarm        = 0x06,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 7,
 };

 // Enum for EndpointListTypeEnum
 enum class EndpointListTypeEnum : uint8_t
 {
     kOther = 0x00,
     kRoom  = 0x01,
     kZone  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Bitmap for CommandBits
 enum class CommandBits : uint16_t
 {
     kInstantAction               = 0x1,
     kInstantActionWithTransition = 0x2,
     kStartAction                 = 0x4,
     kStartActionWithDuration     = 0x8,
     kStopAction                  = 0x10,
     kPauseAction                 = 0x20,
     kPauseActionWithDuration     = 0x40,
     kResumeAction                = 0x80,
     kEnableAction                = 0x100,
     kEnableActionWithDuration    = 0x200,
     kDisableAction               = 0x400,
     kDisableActionWithDuration   = 0x800,
 };
 } // namespace Actions

 namespace BasicInformation {

 // Enum for ColorEnum
 enum class ColorEnum : uint8_t
 {
     kBlack   = 0x00,
     kNavy    = 0x01,
     kGreen   = 0x02,
     kTeal    = 0x03,
     kMaroon  = 0x04,
     kPurple  = 0x05,
     kOlive   = 0x06,
     kGray    = 0x07,
     kBlue    = 0x08,
     kLime    = 0x09,
     kAqua    = 0x0A,
     kRed     = 0x0B,
     kFuchsia = 0x0C,
     kYellow  = 0x0D,
     kWhite   = 0x0E,
     kNickel  = 0x0F,
     kChrome  = 0x10,
     kBrass   = 0x11,
     kCopper  = 0x12,
     kSilver  = 0x13,
     kGold    = 0x14,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 21,
 };

 // Enum for ProductFinishEnum
 enum class ProductFinishEnum : uint8_t
 {
     kOther    = 0x00,
     kMatte    = 0x01,
     kSatin    = 0x02,
     kPolished = 0x03,
     kRugged   = 0x04,
     kFabric   = 0x05,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 6,
 };
 } // namespace BasicInformation

 namespace OtaSoftwareUpdateProvider {

 // Enum for OTAApplyUpdateAction
 enum class OTAApplyUpdateAction : uint8_t
 {
     kProceed         = 0x00,
     kAwaitNextAction = 0x01,
     kDiscontinue     = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for OTADownloadProtocol
 enum class OTADownloadProtocol : uint8_t
 {
     kBDXSynchronous  = 0x00,
     kBDXAsynchronous = 0x01,
     kHttps           = 0x02,
     kVendorSpecific  = 0x03,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 4,
 };

 // Enum for OTAQueryStatus
 enum class OTAQueryStatus : uint8_t
 {
     kUpdateAvailable              = 0x00,
     kBusy                         = 0x01,
     kNotAvailable                 = 0x02,
     kDownloadProtocolNotSupported = 0x03,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 4,
 };
 } // namespace OtaSoftwareUpdateProvider

 namespace OtaSoftwareUpdateRequestor {

 // Enum for OTAAnnouncementReason
 enum class OTAAnnouncementReason : uint8_t
 {
     kSimpleAnnouncement    = 0x00,
     kUpdateAvailable       = 0x01,
     kUrgentUpdateAvailable = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for OTAChangeReasonEnum
 enum class OTAChangeReasonEnum : uint8_t
 {
     kUnknown         = 0x00,
     kSuccess         = 0x01,
     kFailure         = 0x02,
     kTimeOut         = 0x03,
     kDelayByProvider = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for OTAUpdateStateEnum
 enum class OTAUpdateStateEnum : uint8_t
 {
     kUnknown              = 0x00,
     kIdle                 = 0x01,
     kQuerying             = 0x02,
     kDelayedOnQuery       = 0x03,
     kDownloading          = 0x04,
     kApplying             = 0x05,
     kDelayedOnApply       = 0x06,
     kRollingBack          = 0x07,
     kDelayedOnUserConsent = 0x08,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 9,
 };
 } // namespace OtaSoftwareUpdateRequestor

 namespace LocalizationConfiguration {} // namespace LocalizationConfiguration

 namespace TimeFormatLocalization {

 // Enum for CalendarTypeEnum
 enum class CalendarTypeEnum : uint8_t
 {
     kBuddhist  = 0x00,
     kChinese   = 0x01,
     kCoptic    = 0x02,
     kEthiopian = 0x03,
     kGregorian = 0x04,
     kHebrew    = 0x05,
     kIndian    = 0x06,
     kIslamic   = 0x07,
     kJapanese  = 0x08,
     kKorean    = 0x09,
     kPersian   = 0x0A,
     kTaiwanese = 0x0B,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 12,
 };

 // Enum for HourFormatEnum
 enum class HourFormatEnum : uint8_t
 {
     k12hr = 0x00,
     k24hr = 0x01,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };
 } // namespace TimeFormatLocalization

 namespace UnitLocalization {

 // Enum for TempUnitEnum
 enum class TempUnitEnum : uint8_t
 {
     kFahrenheit = 0x00,
     kCelsius    = 0x01,
     kKelvin     = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kTemperatureUnit = 0x1,
 };
 } // namespace UnitLocalization

 namespace PowerSourceConfiguration {} // namespace PowerSourceConfiguration

 namespace PowerSource {

 // Enum for BatApprovedChemistryEnum
 enum class BatApprovedChemistryEnum : uint16_t
 {
     kUnspecified             = 0x00,
     kAlkaline                = 0x01,
     kLithiumCarbonFluoride   = 0x02,
     kLithiumChromiumOxide    = 0x03,
     kLithiumCopperOxide      = 0x04,
     kLithiumIronDisulfide    = 0x05,
     kLithiumManganeseDioxide = 0x06,
     kLithiumThionylChloride  = 0x07,
     kMagnesium               = 0x08,
     kMercuryOxide            = 0x09,
     kNickelOxyhydride        = 0x0A,
     kSilverOxide             = 0x0B,
     kZincAir                 = 0x0C,
     kZincCarbon              = 0x0D,
     kZincChloride            = 0x0E,
     kZincManganeseDioxide    = 0x0F,
     kLeadAcid                = 0x10,
     kLithiumCobaltOxide      = 0x11,
     kLithiumIon              = 0x12,
     kLithiumIonPolymer       = 0x13,
     kLithiumIronPhosphate    = 0x14,
     kLithiumSulfur           = 0x15,
     kLithiumTitanate         = 0x16,
     kNickelCadmium           = 0x17,
     kNickelHydrogen          = 0x18,
     kNickelIron              = 0x19,
     kNickelMetalHydride      = 0x1A,
     kNickelZinc              = 0x1B,
     kSilverZinc              = 0x1C,
     kSodiumIon               = 0x1D,
     kSodiumSulfur            = 0x1E,
     kZincBromide             = 0x1F,
     kZincCerium              = 0x20,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 33,
 };

 // Enum for BatChargeFaultEnum
 enum class BatChargeFaultEnum : uint8_t
 {
     kUnspecified         = 0x00,
     kAmbientTooHot       = 0x01,
     kAmbientTooCold      = 0x02,
     kBatteryTooHot       = 0x03,
     kBatteryTooCold      = 0x04,
     kBatteryAbsent       = 0x05,
     kBatteryOverVoltage  = 0x06,
     kBatteryUnderVoltage = 0x07,
     kChargerOverVoltage  = 0x08,
     kChargerUnderVoltage = 0x09,
     kSafetyTimeout       = 0x0A,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 11,
 };

 // Enum for BatChargeLevelEnum
 enum class BatChargeLevelEnum : uint8_t
 {
     kOk       = 0x00,
     kWarning  = 0x01,
     kCritical = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for BatChargeStateEnum
 enum class BatChargeStateEnum : uint8_t
 {
     kUnknown        = 0x00,
     kIsCharging     = 0x01,
     kIsAtFullCharge = 0x02,
     kIsNotCharging  = 0x03,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 4,
 };

 // Enum for BatCommonDesignationEnum
 enum class BatCommonDesignationEnum : uint16_t
 {
     kUnspecified = 0x00,
     kAaa         = 0x01,
     kAa          = 0x02,
     kC           = 0x03,
     kD           = 0x04,
     k4v5         = 0x05,
     k6v0         = 0x06,
     k9v0         = 0x07,
     k12aa        = 0x08,
     kAaaa        = 0x09,
     kA           = 0x0A,
     kB           = 0x0B,
     kF           = 0x0C,
     kN           = 0x0D,
     kNo6         = 0x0E,
     kSubC        = 0x0F,
     kA23         = 0x10,
     kA27         = 0x11,
     kBa5800      = 0x12,
     kDuplex      = 0x13,
     k4sr44       = 0x14,
     k523         = 0x15,
     k531         = 0x16,
     k15v0        = 0x17,
     k22v5        = 0x18,
     k30v0        = 0x19,
     k45v0        = 0x1A,
     k67v5        = 0x1B,
     kJ           = 0x1C,
     kCr123a      = 0x1D,
     kCr2         = 0x1E,
     k2cr5        = 0x1F,
     kCrP2        = 0x20,
     kCrV3        = 0x21,
     kSr41        = 0x22,
     kSr43        = 0x23,
     kSr44        = 0x24,
     kSr45        = 0x25,
     kSr48        = 0x26,
     kSr54        = 0x27,
     kSr55        = 0x28,
     kSr57        = 0x29,
     kSr58        = 0x2A,
     kSr59        = 0x2B,
     kSr60        = 0x2C,
     kSr63        = 0x2D,
     kSr64        = 0x2E,
     kSr65        = 0x2F,
     kSr66        = 0x30,
     kSr67        = 0x31,
     kSr68        = 0x32,
     kSr69        = 0x33,
     kSr516       = 0x34,
     kSr731       = 0x35,
     kSr712       = 0x36,
     kLr932       = 0x37,
     kA5          = 0x38,
     kA10         = 0x39,
     kA13         = 0x3A,
     kA312        = 0x3B,
     kA675        = 0x3C,
     kAc41e       = 0x3D,
     k10180       = 0x3E,
     k10280       = 0x3F,
     k10440       = 0x40,
     k14250       = 0x41,
     k14430       = 0x42,
     k14500       = 0x43,
     k14650       = 0x44,
     k15270       = 0x45,
     k16340       = 0x46,
     kRcr123a     = 0x47,
     k17500       = 0x48,
     k17670       = 0x49,
     k18350       = 0x4A,
     k18500       = 0x4B,
     k18650       = 0x4C,
     k19670       = 0x4D,
     k25500       = 0x4E,
     k26650       = 0x4F,
     k32600       = 0x50,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 81,
 };

 // Enum for BatFaultEnum
 enum class BatFaultEnum : uint8_t
 {
     kUnspecified = 0x00,
     kOverTemp    = 0x01,
     kUnderTemp   = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for BatReplaceabilityEnum
 enum class BatReplaceabilityEnum : uint8_t
 {
     kUnspecified        = 0x00,
     kNotReplaceable     = 0x01,
     kUserReplaceable    = 0x02,
     kFactoryReplaceable = 0x03,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 4,
 };

 // Enum for PowerSourceStatusEnum
 enum class PowerSourceStatusEnum : uint8_t
 {
     kUnspecified = 0x00,
     kActive      = 0x01,
     kStandby     = 0x02,
     kUnavailable = 0x03,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 4,
 };

 // Enum for WiredCurrentTypeEnum
 enum class WiredCurrentTypeEnum : uint8_t
 {
     kAc = 0x00,
     kDc = 0x01,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };

 // Enum for WiredFaultEnum
 enum class WiredFaultEnum : uint8_t
 {
     kUnspecified  = 0x00,
     kOverVoltage  = 0x01,
     kUnderVoltage = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kWired        = 0x1,
     kBattery      = 0x2,
     kRechargeable = 0x4,
     kReplaceable  = 0x8,
 };
 } // namespace PowerSource

 namespace GeneralCommissioning {

 // Enum for CommissioningErrorEnum
 enum class CommissioningErrorEnum : uint8_t
 {
     kOk                    = 0x00,
     kValueOutsideRange     = 0x01,
     kInvalidAuthentication = 0x02,
     kNoFailSafe            = 0x03,
     kBusyWithOtherAdmin    = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for RegulatoryLocationTypeEnum
 enum class RegulatoryLocationTypeEnum : uint8_t
 {
     kIndoor        = 0x00,
     kOutdoor       = 0x01,
     kIndoorOutdoor = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };
 } // namespace GeneralCommissioning

 namespace NetworkCommissioning {

 // Enum for NetworkCommissioningStatusEnum
 enum class NetworkCommissioningStatusEnum : uint8_t
 {
     kSuccess                = 0x00,
     kOutOfRange             = 0x01,
     kBoundsExceeded         = 0x02,
     kNetworkIDNotFound      = 0x03,
     kDuplicateNetworkID     = 0x04,
     kNetworkNotFound        = 0x05,
     kRegulatoryError        = 0x06,
     kAuthFailure            = 0x07,
     kUnsupportedSecurity    = 0x08,
     kOtherConnectionFailure = 0x09,
     kIPV6Failed             = 0x0A,
     kIPBindFailed           = 0x0B,
     kUnknownError           = 0x0C,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 13,
 };

 // Enum for WiFiBandEnum
 enum class WiFiBandEnum : uint8_t
 {
     k2g4  = 0x00,
     k3g65 = 0x01,
     k5g   = 0x02,
     k6g   = 0x03,
     k60g  = 0x04,
     k1g   = 0x05,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 6,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kWiFiNetworkInterface     = 0x1,
     kThreadNetworkInterface   = 0x2,
     kEthernetNetworkInterface = 0x4,
 };

 // Bitmap for WiFiSecurityBitmap
 enum class WiFiSecurityBitmap : uint8_t
 {
     kUnencrypted  = 0x1,
     kWep          = 0x2,
     kWpaPersonal  = 0x4,
     kWpa2Personal = 0x8,
     kWpa3Personal = 0x10,
 };
 } // namespace NetworkCommissioning

 namespace DiagnosticLogs {

 // Enum for IntentEnum
 enum class IntentEnum : uint8_t
 {
     kEndUserSupport = 0x00,
     kNetworkDiag    = 0x01,
     kCrashLogs      = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for StatusEnum
 enum class StatusEnum : uint8_t
 {
     kSuccess   = 0x00,
     kExhausted = 0x01,
     kNoLogs    = 0x02,
     kBusy      = 0x03,
     kDenied    = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for TransferProtocolEnum
 enum class TransferProtocolEnum : uint8_t
 {
     kResponsePayload = 0x00,
     kBdx             = 0x01,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };
 } // namespace DiagnosticLogs

 namespace GeneralDiagnostics {

 // Enum for BootReasonEnum
 enum class BootReasonEnum : uint8_t
 {
     kUnspecified             = 0x00,
     kPowerOnReboot           = 0x01,
     kBrownOutReset           = 0x02,
     kSoftwareWatchdogReset   = 0x03,
     kHardwareWatchdogReset   = 0x04,
     kSoftwareUpdateCompleted = 0x05,
     kSoftwareReset           = 0x06,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 7,
 };

 // Enum for HardwareFaultEnum
 enum class HardwareFaultEnum : uint8_t
 {
     kUnspecified            = 0x00,
     kRadio                  = 0x01,
     kSensor                 = 0x02,
     kResettableOverTemp     = 0x03,
     kNonResettableOverTemp  = 0x04,
     kPowerSource            = 0x05,
     kVisualDisplayFault     = 0x06,
     kAudioOutputFault       = 0x07,
     kUserInterfaceFault     = 0x08,
     kNonVolatileMemoryError = 0x09,
     kTamperDetected         = 0x0A,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 11,
 };

 // Need to convert consumers to using the new enum classes, so we
 // don't just have casts all over.
 #ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
 // Enum for InterfaceTypeEnum
 enum class InterfaceTypeEnum : uint8_t
 {
     kUnspecified = 0x00,
     kWiFi        = 0x01,
     kEthernet    = 0x02,
     kCellular    = 0x03,
     kThread      = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };
 #else  // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
 using InterfaceTypeEnum                                                              = EmberAfInterfaceTypeEnum;
 static InterfaceTypeEnum __attribute__((unused)) kInterfaceTypeEnumkUnknownEnumValue = static_cast<InterfaceTypeEnum>(5);
 #endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM

 // Enum for NetworkFaultEnum
 enum class NetworkFaultEnum : uint8_t
 {
     kUnspecified      = 0x00,
     kHardwareFailure  = 0x01,
     kNetworkJammed    = 0x02,
     kConnectionFailed = 0x03,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 4,
 };

 // Need to convert consumers to using the new enum classes, so we
 // don't just have casts all over.
 #ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
 // Enum for RadioFaultEnum
 enum class RadioFaultEnum : uint8_t
 {
     kUnspecified   = 0x00,
     kWiFiFault     = 0x01,
     kCellularFault = 0x02,
     kThreadFault   = 0x03,
     kNFCFault      = 0x04,
     kBLEFault      = 0x05,
     kEthernetFault = 0x06,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 7,
 };
 #else  // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
 using RadioFaultEnum                                                           = EmberAfRadioFaultEnum;
 static RadioFaultEnum __attribute__((unused)) kRadioFaultEnumkUnknownEnumValue = static_cast<RadioFaultEnum>(7);
 #endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
 } // namespace GeneralDiagnostics

 namespace SoftwareDiagnostics {

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kWaterMarks = 0x1,
 };
 } // namespace SoftwareDiagnostics

 namespace ThreadNetworkDiagnostics {

 // Enum for ConnectionStatusEnum
 enum class ConnectionStatusEnum : uint8_t
 {
     kConnected    = 0x00,
     kNotConnected = 0x01,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };

 // Enum for NetworkFaultEnum
 enum class NetworkFaultEnum : uint8_t
 {
     kUnspecified     = 0x00,
     kLinkDown        = 0x01,
     kHardwareFailure = 0x02,
     kNetworkJammed   = 0x03,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 4,
 };

 // Enum for RoutingRoleEnum
 enum class RoutingRoleEnum : uint8_t
 {
     kUnspecified     = 0x00,
     kUnassigned      = 0x01,
     kSleepyEndDevice = 0x02,
     kEndDevice       = 0x03,
     kReed            = 0x04,
     kRouter          = 0x05,
     kLeader          = 0x06,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 7,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kPacketCounts = 0x1,
     kErrorCounts  = 0x2,
     kMLECounts    = 0x4,
     kMACCounts    = 0x8,
 };
 } // namespace ThreadNetworkDiagnostics

 namespace WiFiNetworkDiagnostics {

 // Enum for AssociationFailureCauseEnum
 enum class AssociationFailureCauseEnum : uint8_t
 {
     kUnknown              = 0x00,
     kAssociationFailed    = 0x01,
     kAuthenticationFailed = 0x02,
     kSsidNotFound         = 0x03,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 4,
 };

 // Enum for ConnectionStatusEnum
 enum class ConnectionStatusEnum : uint8_t
 {
     kConnected    = 0x00,
     kNotConnected = 0x01,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };

 // Enum for SecurityTypeEnum
 enum class SecurityTypeEnum : uint8_t
 {
     kUnspecified = 0x00,
     kNone        = 0x01,
     kWep         = 0x02,
     kWpa         = 0x03,
     kWpa2        = 0x04,
     kWpa3        = 0x05,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 6,
 };

 // Enum for WiFiVersionEnum
 enum class WiFiVersionEnum : uint8_t
 {
     kA  = 0x00,
     kB  = 0x01,
     kG  = 0x02,
     kN  = 0x03,
     kAc = 0x04,
     kAx = 0x05,
     kAh = 0x06,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 7,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kPacketCounts = 0x1,
     kErrorCounts  = 0x2,
 };
 } // namespace WiFiNetworkDiagnostics

 namespace EthernetNetworkDiagnostics {

 // Need to convert consumers to using the new enum classes, so we
 // don't just have casts all over.
 #ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
 // Enum for PHYRateEnum
 enum class PHYRateEnum : uint8_t
 {
     kRate10M  = 0x00,
     kRate100M = 0x01,
     kRate1G   = 0x02,
     kRate25g  = 0x03,
     kRate5G   = 0x04,
     kRate10G  = 0x05,
     kRate40G  = 0x06,
     kRate100G = 0x07,
     kRate200G = 0x08,
     kRate400G = 0x09,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 10,
 };
 #else  // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
 using PHYRateEnum                                                        = EmberAfPHYRateEnum;
 static PHYRateEnum __attribute__((unused)) kPHYRateEnumkUnknownEnumValue = static_cast<PHYRateEnum>(10);
 #endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kPacketCounts = 0x1,
     kErrorCounts  = 0x2,
 };
 } // namespace EthernetNetworkDiagnostics

 namespace TimeSynchronization {

 // Enum for GranularityEnum
 enum class GranularityEnum : uint8_t
 {
     kNoTimeGranularity       = 0x00,
     kMinutesGranularity      = 0x01,
     kSecondsGranularity      = 0x02,
     kMillisecondsGranularity = 0x03,
     kMicrosecondsGranularity = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for StatusCode
 enum class StatusCode : uint8_t
 {
     kTimeNotAccepted = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 0,
 };

 // Enum for TimeSourceEnum
 enum class TimeSourceEnum : uint8_t
 {
     kNone             = 0x00,
     kUnknown          = 0x01,
     kAdmin            = 0x02,
     kNodeTimeCluster  = 0x03,
     kNonMatterSNTP    = 0x04,
     kNonMatterNTP     = 0x05,
     kMatterSNTP       = 0x06,
     kMatterNTP        = 0x07,
     kMixedNTP         = 0x08,
     kNonMatterSNTPNTS = 0x09,
     kNonMatterNTPNTS  = 0x0A,
     kMatterSNTPNTS    = 0x0B,
     kMatterNTPNTS     = 0x0C,
     kMixedNTPNTS      = 0x0D,
     kCloudSource      = 0x0E,
     kPtp              = 0x0F,
     kGnss             = 0x10,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 17,
 };

 // Enum for TimeZoneDatabaseEnum
 enum class TimeZoneDatabaseEnum : uint8_t
 {
     kFull    = 0x00,
     kPartial = 0x01,
     kNone    = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kTimeZone       = 0x1,
     kNTPClient      = 0x2,
     kNTPServer      = 0x4,
     kTimeSyncClient = 0x8,
 };
 } // namespace TimeSynchronization

 namespace BridgedDeviceBasicInformation {

 // Enum for ColorEnum
 enum class ColorEnum : uint8_t
 {
     kBlack   = 0x00,
     kNavy    = 0x01,
     kGreen   = 0x02,
     kTeal    = 0x03,
     kMaroon  = 0x04,
     kPurple  = 0x05,
     kOlive   = 0x06,
     kGray    = 0x07,
     kBlue    = 0x08,
     kLime    = 0x09,
     kAqua    = 0x0A,
     kRed     = 0x0B,
     kFuchsia = 0x0C,
     kYellow  = 0x0D,
     kWhite   = 0x0E,
     kNickel  = 0x0F,
     kChrome  = 0x10,
     kBrass   = 0x11,
     kCopper  = 0x12,
     kSilver  = 0x13,
     kGold    = 0x14,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 21,
 };

 // Enum for ProductFinishEnum
 enum class ProductFinishEnum : uint8_t
 {
     kOther    = 0x00,
     kMatte    = 0x01,
     kSatin    = 0x02,
     kPolished = 0x03,
     kRugged   = 0x04,
     kFabric   = 0x05,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 6,
 };
 } // namespace BridgedDeviceBasicInformation

 namespace Switch {

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kLatchingSwitch            = 0x1,
     kMomentarySwitch           = 0x2,
     kMomentarySwitchRelease    = 0x4,
     kMomentarySwitchLongPress  = 0x8,
     kMomentarySwitchMultiPress = 0x10,
 };
 } // namespace Switch

 namespace AdministratorCommissioning {

 // Enum for CommissioningWindowStatusEnum
 enum class CommissioningWindowStatusEnum : uint8_t
 {
     kWindowNotOpen      = 0x00,
     kEnhancedWindowOpen = 0x01,
     kBasicWindowOpen    = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for StatusCode
 enum class StatusCode : uint8_t
 {
     kBusy               = 0x02,
     kPAKEParameterError = 0x03,
     kWindowNotOpen      = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 0,
 };
 } // namespace AdministratorCommissioning

 namespace OperationalCredentials {

 // Enum for CertificateChainTypeEnum
 enum class CertificateChainTypeEnum : uint8_t
 {
     kDACCertificate = 0x01,
     kPAICertificate = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 0,
 };

 // Enum for NodeOperationalCertStatusEnum
 enum class NodeOperationalCertStatusEnum : uint8_t
 {
     kOk                  = 0x00,
     kInvalidPublicKey    = 0x01,
     kInvalidNodeOpId     = 0x02,
     kInvalidNOC          = 0x03,
     kMissingCsr          = 0x04,
     kTableFull           = 0x05,
     kInvalidAdminSubject = 0x06,
     kFabricConflict      = 0x09,
     kLabelConflict       = 0x0A,
     kInvalidFabricIndex  = 0x0B,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 7,
 };
 } // namespace OperationalCredentials

 namespace GroupKeyManagement {

 // Enum for GroupKeySecurityPolicyEnum
 enum class GroupKeySecurityPolicyEnum : uint8_t
 {
     kTrustFirst   = 0x00,
     kCacheAndSync = 0x01,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };
 } // namespace GroupKeyManagement

 namespace FixedLabel {} // namespace FixedLabel

 namespace UserLabel {} // namespace UserLabel

 namespace ProxyConfiguration {} // namespace ProxyConfiguration

 namespace ProxyDiscovery {} // namespace ProxyDiscovery

 namespace ProxyValid {} // namespace ProxyValid

 namespace BooleanState {} // namespace BooleanState

 namespace IcdManagement {

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kCheckInProtocolSupport = 0x1,
 };
 } // namespace IcdManagement

 namespace ModeSelect {

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kOnOff = 0x1,
 };
 } // namespace ModeSelect

 namespace LaundryWasherMode {

 // Enum for ModeTag
 enum class ModeTag : uint16_t
 {
     kNormal   = 0x4000,
     kDelicate = 0x4001,
     kHeavy    = 0x4002,
     kWhites   = 0x4003,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 0,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kOnOff = 0x1,
 };
 } // namespace LaundryWasherMode

 namespace RefrigeratorAndTemperatureControlledCabinetMode {

 // Enum for ModeTag
 enum class ModeTag : uint16_t
 {
     kRapidCool   = 0x4000,
     kRapidFreeze = 0x4001,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 0,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kOnOff = 0x1,
 };
 } // namespace RefrigeratorAndTemperatureControlledCabinetMode

 namespace LaundryWasherControls {

 // Enum for NumberOfRinsesEnum
 enum class NumberOfRinsesEnum : uint8_t
 {
     kNone   = 0x00,
     kNormal = 0x01,
     kExtra  = 0x02,
     kMax    = 0x03,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 4,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kSpin  = 0x1,
     kRinse = 0x2,
 };
 } // namespace LaundryWasherControls

 namespace RvcRunMode {

 // Enum for ModeTag
 enum class ModeTag : uint16_t
 {
     kIdle     = 0x4000,
     kCleaning = 0x4001,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 0,
 };

 // Enum for StatusCode
 enum class StatusCode : uint8_t
 {
     kStuck                 = 0x41,
     kDustBinMissing        = 0x42,
     kDustBinFull           = 0x43,
     kWaterTankEmpty        = 0x44,
     kWaterTankMissing      = 0x45,
     kWaterTankLidOpen      = 0x46,
     kMopCleaningPadMissing = 0x47,
     kBatteryLow            = 0x48,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 0,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kOnOff = 0x1,
 };
 } // namespace RvcRunMode

 namespace RvcCleanMode {

 // Enum for ModeTag
 enum class ModeTag : uint16_t
 {
     kDeepClean = 0x4000,
     kVacuum    = 0x4001,
     kMop       = 0x4002,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 0,
 };

 // Enum for StatusCode
 enum class StatusCode : uint8_t
 {
     kCleaningInProgress = 0x40,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 0,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kOnOff = 0x1,
 };
 } // namespace RvcCleanMode

 namespace TemperatureControl {

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kTemperatureNumber = 0x1,
     kTemperatureLevel  = 0x2,
     kTemperatureStep   = 0x4,
 };
 } // namespace TemperatureControl

 namespace RefrigeratorAlarm {

 // Bitmap for AlarmMap
 enum class AlarmMap : uint32_t
 {
     kDoorOpen = 0x1,
 };
 } // namespace RefrigeratorAlarm

 namespace DishwasherMode {

 // Enum for ModeTag
 enum class ModeTag : uint16_t
 {
     kNormal = 0x4000,
     kHeavy  = 0x4001,
     kLight  = 0x4002,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 0,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kOnOff = 0x1,
 };
 } // namespace DishwasherMode

 namespace AirQuality {

 // Enum for AirQualityEnum
 enum class AirQualityEnum : uint8_t
 {
     kUnknown       = 0x00,
     kGood          = 0x01,
     kFair          = 0x02,
     kModerate      = 0x03,
     kPoor          = 0x04,
     kVeryPoor      = 0x05,
     kExtremelyPoor = 0x06,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 7,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kFair          = 0x1,
     kModerate      = 0x2,
     kVeryPoor      = 0x4,
     kExtremelyPoor = 0x8,
 };
 } // namespace AirQuality

 namespace SmokeCoAlarm {

 // Enum for AlarmStateEnum
 enum class AlarmStateEnum : uint8_t
 {
     kNormal   = 0x00,
     kWarning  = 0x01,
     kCritical = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for ContaminationStateEnum
 enum class ContaminationStateEnum : uint8_t
 {
     kNormal   = 0x00,
     kLow      = 0x01,
     kWarning  = 0x02,
     kCritical = 0x03,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 4,
 };

 // Enum for EndOfServiceEnum
 enum class EndOfServiceEnum : uint8_t
 {
     kNormal  = 0x00,
     kExpired = 0x01,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };

 // Enum for ExpressedStateEnum
 enum class ExpressedStateEnum : uint8_t
 {
     kNormal            = 0x00,
     kSmokeAlarm        = 0x01,
     kCOAlarm           = 0x02,
     kBatteryAlert      = 0x03,
     kTesting           = 0x04,
     kHardwareFault     = 0x05,
     kEndOfService      = 0x06,
     kInterconnectSmoke = 0x07,
     kInterconnectCO    = 0x08,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 9,
 };

 // Enum for MuteStateEnum
 enum class MuteStateEnum : uint8_t
 {
     kNotMuted = 0x00,
     kMuted    = 0x01,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };

 // Enum for SensitivityEnum
 enum class SensitivityEnum : uint8_t
 {
     kHigh     = 0x00,
     kStandard = 0x01,
     kLow      = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kSmokeAlarm = 0x1,
     kCoAlarm    = 0x2,
 };
 } // namespace SmokeCoAlarm

 namespace DishwasherAlarm {

 // Bitmap for AlarmMap
 enum class AlarmMap : uint32_t
 {
     kInflowError     = 0x1,
     kDrainError      = 0x2,
     kDoorError       = 0x4,
     kTempTooLow      = 0x8,
     kTempTooHigh     = 0x10,
     kWaterLevelError = 0x20,
 };
 } // namespace DishwasherAlarm

 namespace OperationalState {

 // Enum for ErrorStateEnum
 enum class ErrorStateEnum : uint8_t
 {
     kNoError                   = 0x00,
     kUnableToStartOrResume     = 0x01,
     kUnableToCompleteOperation = 0x02,
     kCommandInvalidInState     = 0x03,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 4,
 };

 // Enum for OperationalStateEnum
 enum class OperationalStateEnum : uint8_t
 {
     kStopped = 0x00,
     kRunning = 0x01,
     kPaused  = 0x02,
     kError   = 0x03,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 4,
 };
 } // namespace OperationalState

 namespace RvcOperationalState {

 // Enum for ErrorStateEnum
 enum class ErrorStateEnum : uint8_t
 {
     kFailedToFindChargingDock = 0x40,
     kStuck                    = 0x41,
     kDustBinMissing           = 0x42,
     kDustBinFull              = 0x43,
     kWaterTankEmpty           = 0x44,
     kWaterTankMissing         = 0x45,
     kWaterTankLidOpen         = 0x46,
     kMopCleaningPadMissing    = 0x47,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 0,
 };

 // Enum for OperationalStateEnum
 enum class OperationalStateEnum : uint8_t
 {
     kSeekingCharger = 0x40,
     kCharging       = 0x41,
     kDocked         = 0x42,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 0,
 };
 } // namespace RvcOperationalState

 namespace HepaFilterMonitoring {

 // Enum for ChangeIndicationEnum
 enum class ChangeIndicationEnum : uint8_t
 {
     kOk       = 0x00,
     kWarning  = 0x01,
     kCritical = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for DegradationDirectionEnum
 enum class DegradationDirectionEnum : uint8_t
 {
     kUp   = 0x00,
     kDown = 0x01,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };

 // Enum for ProductIdentifierTypeEnum
 enum class ProductIdentifierTypeEnum : uint8_t
 {
     kUpc    = 0x00,
     kGtin8  = 0x01,
     kEan    = 0x02,
     kGtin14 = 0x03,
     kOem    = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kCondition = 0x1,
     kWarning   = 0x2,
 };
 } // namespace HepaFilterMonitoring

 namespace ActivatedCarbonFilterMonitoring {

 // Enum for ChangeIndicationEnum
 enum class ChangeIndicationEnum : uint8_t
 {
     kOk       = 0x00,
     kWarning  = 0x01,
     kCritical = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for DegradationDirectionEnum
 enum class DegradationDirectionEnum : uint8_t
 {
     kUp   = 0x00,
     kDown = 0x01,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };

 // Enum for ProductIdentifierTypeEnum
 enum class ProductIdentifierTypeEnum : uint8_t
 {
     kUpc    = 0x00,
     kGtin8  = 0x01,
     kEan    = 0x02,
     kGtin14 = 0x03,
     kOem    = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kCondition = 0x1,
     kWarning   = 0x2,
 };
 } // namespace ActivatedCarbonFilterMonitoring

 namespace CeramicFilterMonitoring {

 // Enum for ChangeIndicationEnum
 enum class ChangeIndicationEnum : uint8_t
 {
     kOk       = 0x00,
     kWarning  = 0x01,
     kCritical = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for DegradationDirectionEnum
 enum class DegradationDirectionEnum : uint8_t
 {
     kUp   = 0x00,
     kDown = 0x01,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };

 // Enum for ProductIdentifierTypeEnum
 enum class ProductIdentifierTypeEnum : uint8_t
 {
     kUpc    = 0x00,
     kGtin8  = 0x01,
     kEan    = 0x02,
     kGtin14 = 0x03,
     kOem    = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kCondition = 0x1,
     kWarning   = 0x2,
 };
 } // namespace CeramicFilterMonitoring

 namespace ElectrostaticFilterMonitoring {

 // Enum for ChangeIndicationEnum
 enum class ChangeIndicationEnum : uint8_t
 {
     kOk       = 0x00,
     kWarning  = 0x01,
     kCritical = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for DegradationDirectionEnum
 enum class DegradationDirectionEnum : uint8_t
 {
     kUp   = 0x00,
     kDown = 0x01,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };

 // Enum for ProductIdentifierTypeEnum
 enum class ProductIdentifierTypeEnum : uint8_t
 {
     kUpc    = 0x00,
     kGtin8  = 0x01,
     kEan    = 0x02,
     kGtin14 = 0x03,
     kOem    = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kCondition = 0x1,
     kWarning   = 0x2,
 };
 } // namespace ElectrostaticFilterMonitoring

 namespace UvFilterMonitoring {

 // Enum for ChangeIndicationEnum
 enum class ChangeIndicationEnum : uint8_t
 {
     kOk       = 0x00,
     kWarning  = 0x01,
     kCritical = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for DegradationDirectionEnum
 enum class DegradationDirectionEnum : uint8_t
 {
     kUp   = 0x00,
     kDown = 0x01,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };

 // Enum for ProductIdentifierTypeEnum
 enum class ProductIdentifierTypeEnum : uint8_t
 {
     kUpc    = 0x00,
     kGtin8  = 0x01,
     kEan    = 0x02,
     kGtin14 = 0x03,
     kOem    = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kCondition = 0x1,
     kWarning   = 0x2,
 };
 } // namespace UvFilterMonitoring

 namespace IonizingFilterMonitoring {

 // Enum for ChangeIndicationEnum
 enum class ChangeIndicationEnum : uint8_t
 {
     kOk       = 0x00,
     kWarning  = 0x01,
     kCritical = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for DegradationDirectionEnum
 enum class DegradationDirectionEnum : uint8_t
 {
     kUp   = 0x00,
     kDown = 0x01,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };

 // Enum for ProductIdentifierTypeEnum
 enum class ProductIdentifierTypeEnum : uint8_t
 {
     kUpc    = 0x00,
     kGtin8  = 0x01,
     kEan    = 0x02,
     kGtin14 = 0x03,
     kOem    = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kCondition = 0x1,
     kWarning   = 0x2,
 };
 } // namespace IonizingFilterMonitoring

 namespace ZeoliteFilterMonitoring {

 // Enum for ChangeIndicationEnum
 enum class ChangeIndicationEnum : uint8_t
 {
     kOk       = 0x00,
     kWarning  = 0x01,
     kCritical = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for DegradationDirectionEnum
 enum class DegradationDirectionEnum : uint8_t
 {
     kUp   = 0x00,
     kDown = 0x01,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };

 // Enum for ProductIdentifierTypeEnum
 enum class ProductIdentifierTypeEnum : uint8_t
 {
     kUpc    = 0x00,
     kGtin8  = 0x01,
     kEan    = 0x02,
     kGtin14 = 0x03,
     kOem    = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kCondition = 0x1,
     kWarning   = 0x2,
 };
 } // namespace ZeoliteFilterMonitoring

 namespace OzoneFilterMonitoring {

 // Enum for ChangeIndicationEnum
 enum class ChangeIndicationEnum : uint8_t
 {
     kOk       = 0x00,
     kWarning  = 0x01,
     kCritical = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for DegradationDirectionEnum
 enum class DegradationDirectionEnum : uint8_t
 {
     kUp   = 0x00,
     kDown = 0x01,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };

 // Enum for ProductIdentifierTypeEnum
 enum class ProductIdentifierTypeEnum : uint8_t
 {
     kUpc    = 0x00,
     kGtin8  = 0x01,
     kEan    = 0x02,
     kGtin14 = 0x03,
     kOem    = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kCondition = 0x1,
     kWarning   = 0x2,
 };
 } // namespace OzoneFilterMonitoring

 namespace WaterTankMonitoring {

 // Enum for ChangeIndicationEnum
 enum class ChangeIndicationEnum : uint8_t
 {
     kOk       = 0x00,
     kWarning  = 0x01,
     kCritical = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for DegradationDirectionEnum
 enum class DegradationDirectionEnum : uint8_t
 {
     kUp   = 0x00,
     kDown = 0x01,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };

 // Enum for ProductIdentifierTypeEnum
 enum class ProductIdentifierTypeEnum : uint8_t
 {
     kUpc    = 0x00,
     kGtin8  = 0x01,
     kEan    = 0x02,
     kGtin14 = 0x03,
     kOem    = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kCondition = 0x1,
     kWarning   = 0x2,
 };
 } // namespace WaterTankMonitoring

 namespace FuelTankMonitoring {

 // Enum for ChangeIndicationEnum
 enum class ChangeIndicationEnum : uint8_t
 {
     kOk       = 0x00,
     kWarning  = 0x01,
     kCritical = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for DegradationDirectionEnum
 enum class DegradationDirectionEnum : uint8_t
 {
     kUp   = 0x00,
     kDown = 0x01,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };

 // Enum for ProductIdentifierTypeEnum
 enum class ProductIdentifierTypeEnum : uint8_t
 {
     kUpc    = 0x00,
     kGtin8  = 0x01,
     kEan    = 0x02,
     kGtin14 = 0x03,
     kOem    = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kCondition = 0x1,
     kWarning   = 0x2,
 };
 } // namespace FuelTankMonitoring

 namespace InkCartridgeMonitoring {

 // Enum for ChangeIndicationEnum
 enum class ChangeIndicationEnum : uint8_t
 {
     kOk       = 0x00,
     kWarning  = 0x01,
     kCritical = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for DegradationDirectionEnum
 enum class DegradationDirectionEnum : uint8_t
 {
     kUp   = 0x00,
     kDown = 0x01,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };

 // Enum for ProductIdentifierTypeEnum
 enum class ProductIdentifierTypeEnum : uint8_t
 {
     kUpc    = 0x00,
     kGtin8  = 0x01,
     kEan    = 0x02,
     kGtin14 = 0x03,
     kOem    = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kCondition = 0x1,
     kWarning   = 0x2,
 };
 } // namespace InkCartridgeMonitoring

 namespace TonerCartridgeMonitoring {

 // Enum for ChangeIndicationEnum
 enum class ChangeIndicationEnum : uint8_t
 {
     kOk       = 0x00,
     kWarning  = 0x01,
     kCritical = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for DegradationDirectionEnum
 enum class DegradationDirectionEnum : uint8_t
 {
     kUp   = 0x00,
     kDown = 0x01,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };

 // Enum for ProductIdentifierTypeEnum
 enum class ProductIdentifierTypeEnum : uint8_t
 {
     kUpc    = 0x00,
     kGtin8  = 0x01,
     kEan    = 0x02,
     kGtin14 = 0x03,
     kOem    = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kCondition = 0x1,
     kWarning   = 0x2,
 };
 } // namespace TonerCartridgeMonitoring

 namespace DoorLock {

 // Enum for AlarmCodeEnum
 enum class AlarmCodeEnum : uint8_t
 {
     kLockJammed              = 0x00,
     kLockFactoryReset        = 0x01,
     kLockRadioPowerCycled    = 0x03,
     kWrongCodeEntryLimit     = 0x04,
     kFrontEsceutcheonRemoved = 0x05,
     kDoorForcedOpen          = 0x06,
     kDoorAjar                = 0x07,
     kForcedUser              = 0x08,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };

 // Enum for CredentialRuleEnum
 enum class CredentialRuleEnum : uint8_t
 {
     kSingle = 0x00,
     kDual   = 0x01,
     kTri    = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for CredentialTypeEnum
 enum class CredentialTypeEnum : uint8_t
 {
     kProgrammingPIN = 0x00,
     kPin            = 0x01,
     kRfid           = 0x02,
     kFingerprint    = 0x03,
     kFingerVein     = 0x04,
     kFace           = 0x05,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 6,
 };

 // Enum for DataOperationTypeEnum
 enum class DataOperationTypeEnum : uint8_t
 {
     kAdd    = 0x00,
     kClear  = 0x01,
     kModify = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for DlLockState
 enum class DlLockState : uint8_t
 {
     kNotFullyLocked = 0x00,
     kLocked         = 0x01,
     kUnlocked       = 0x02,
     kUnlatched      = 0x03,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 4,
 };

 // Enum for DlLockType
 enum class DlLockType : uint8_t
 {
     kDeadBolt           = 0x00,
     kMagnetic           = 0x01,
     kOther              = 0x02,
     kMortise            = 0x03,
     kRim                = 0x04,
     kLatchBolt          = 0x05,
     kCylindricalLock    = 0x06,
     kTubularLock        = 0x07,
     kInterconnectedLock = 0x08,
     kDeadLatch          = 0x09,
     kDoorFurniture      = 0x0A,
     kEurocylinder       = 0x0B,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 12,
 };

 // Enum for DlStatus
 enum class DlStatus : uint8_t
 {
     kSuccess           = 0x00,
     kFailure           = 0x01,
     kDuplicate         = 0x02,
     kOccupied          = 0x03,
     kInvalidField      = 0x85,
     kResourceExhausted = 0x89,
     kNotFound          = 0x8B,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 4,
 };

 // Enum for DoorLockOperationEventCode
 enum class DoorLockOperationEventCode : uint8_t
 {
     kUnknownOrMfgSpecific  = 0x00,
     kLock                  = 0x01,
     kUnlock                = 0x02,
     kLockInvalidPinOrId    = 0x03,
     kLockInvalidSchedule   = 0x04,
     kUnlockInvalidPinOrId  = 0x05,
     kUnlockInvalidSchedule = 0x06,
     kOneTouchLock          = 0x07,
     kKeyLock               = 0x08,
     kKeyUnlock             = 0x09,
     kAutoLock              = 0x0A,
     kScheduleLock          = 0x0B,
     kScheduleUnlock        = 0x0C,
     kManualLock            = 0x0D,
     kManualUnlock          = 0x0E,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 15,
 };

 // Enum for DoorLockProgrammingEventCode
 enum class DoorLockProgrammingEventCode : uint8_t
 {
     kUnknownOrMfgSpecific = 0x00,
     kMasterCodeChanged    = 0x01,
     kPinAdded             = 0x02,
     kPinDeleted           = 0x03,
     kPinChanged           = 0x04,
     kIdAdded              = 0x05,
     kIdDeleted            = 0x06,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 7,
 };

 // Enum for DoorLockSetPinOrIdStatus
 enum class DoorLockSetPinOrIdStatus : uint8_t
 {
     kSuccess            = 0x00,
     kGeneralFailure     = 0x01,
     kMemoryFull         = 0x02,
     kDuplicateCodeError = 0x03,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 4,
 };

 // Enum for DoorLockUserStatus
 enum class DoorLockUserStatus : uint8_t
 {
     kAvailable        = 0x00,
     kOccupiedEnabled  = 0x01,
     kOccupiedDisabled = 0x03,
     kNotSupported     = 0xFF,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };

 // Enum for DoorLockUserType
 enum class DoorLockUserType : uint8_t
 {
     kUnrestricted        = 0x00,
     kYearDayScheduleUser = 0x01,
     kWeekDayScheduleUser = 0x02,
     kMasterUser          = 0x03,
     kNonAccessUser       = 0x04,
     kNotSupported        = 0xFF,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for DoorStateEnum
 enum class DoorStateEnum : uint8_t
 {
     kDoorOpen             = 0x00,
     kDoorClosed           = 0x01,
     kDoorJammed           = 0x02,
     kDoorForcedOpen       = 0x03,
     kDoorUnspecifiedError = 0x04,
     kDoorAjar             = 0x05,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 6,
 };

 // Enum for LockDataTypeEnum
 enum class LockDataTypeEnum : uint8_t
 {
     kUnspecified     = 0x00,
     kProgrammingCode = 0x01,
     kUserIndex       = 0x02,
     kWeekDaySchedule = 0x03,
     kYearDaySchedule = 0x04,
     kHolidaySchedule = 0x05,
     kPin             = 0x06,
     kRfid            = 0x07,
     kFingerprint     = 0x08,
     kFingerVein      = 0x09,
     kFace            = 0x0A,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 11,
 };

 // Enum for LockOperationTypeEnum
 enum class LockOperationTypeEnum : uint8_t
 {
     kLock               = 0x00,
     kUnlock             = 0x01,
     kNonAccessUserEvent = 0x02,
     kForcedUserEvent    = 0x03,
     kUnlatch            = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for OperatingModeEnum
 enum class OperatingModeEnum : uint8_t
 {
     kNormal             = 0x00,
     kVacation           = 0x01,
     kPrivacy            = 0x02,
     kNoRemoteLockUnlock = 0x03,
     kPassage            = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for OperationErrorEnum
 enum class OperationErrorEnum : uint8_t
 {
     kUnspecified         = 0x00,
     kInvalidCredential   = 0x01,
     kDisabledUserDenied  = 0x02,
     kRestricted          = 0x03,
     kInsufficientBattery = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for OperationSourceEnum
 enum class OperationSourceEnum : uint8_t
 {
     kUnspecified       = 0x00,
     kManual            = 0x01,
     kProprietaryRemote = 0x02,
     kKeypad            = 0x03,
     kAuto              = 0x04,
     kButton            = 0x05,
     kSchedule          = 0x06,
     kRemote            = 0x07,
     kRfid              = 0x08,
     kBiometric         = 0x09,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 10,
 };

 // Enum for UserStatusEnum
 enum class UserStatusEnum : uint8_t
 {
     kAvailable        = 0x00,
     kOccupiedEnabled  = 0x01,
     kOccupiedDisabled = 0x03,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };

 // Enum for UserTypeEnum
 enum class UserTypeEnum : uint8_t
 {
     kUnrestrictedUser       = 0x00,
     kYearDayScheduleUser    = 0x01,
     kWeekDayScheduleUser    = 0x02,
     kProgrammingUser        = 0x03,
     kNonAccessUser          = 0x04,
     kForcedUser             = 0x05,
     kDisposableUser         = 0x06,
     kExpiringUser           = 0x07,
     kScheduleRestrictedUser = 0x08,
     kRemoteOnlyUser         = 0x09,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 10,
 };

 // Bitmap for DaysMaskMap
 enum class DaysMaskMap : uint8_t
 {
     kSunday    = 0x1,
     kMonday    = 0x2,
     kTuesday   = 0x4,
     kWednesday = 0x8,
     kThursday  = 0x10,
     kFriday    = 0x20,
     kSaturday  = 0x40,
 };

 // Bitmap for DlCredentialRuleMask
 enum class DlCredentialRuleMask : uint8_t
 {
     kSingle = 0x1,
     kDual   = 0x2,
     kTri    = 0x4,
 };

 // Bitmap for DlCredentialRulesSupport
 enum class DlCredentialRulesSupport : uint8_t
 {
     kSingle = 0x1,
     kDual   = 0x2,
     kTri    = 0x4,
 };

 // Bitmap for DlDefaultConfigurationRegister
 enum class DlDefaultConfigurationRegister : uint16_t
 {
     kEnableLocalProgrammingEnabled         = 0x1,
     kKeypadInterfaceDefaultAccessEnabled   = 0x2,
     kRemoteInterfaceDefaultAccessIsEnabled = 0x4,
     kSoundEnabled                          = 0x20,
     kAutoRelockTimeSet                     = 0x40,
     kLEDSettingsSet                        = 0x80,
 };

 // Bitmap for DlKeypadOperationEventMask
 enum class DlKeypadOperationEventMask : uint16_t
 {
     kUnknown               = 0x1,
     kLock                  = 0x2,
     kUnlock                = 0x4,
     kLockInvalidPIN        = 0x8,
     kLockInvalidSchedule   = 0x10,
     kUnlockInvalidCode     = 0x20,
     kUnlockInvalidSchedule = 0x40,
     kNonAccessUserOpEvent  = 0x80,
 };

 // Bitmap for DlKeypadProgrammingEventMask
 enum class DlKeypadProgrammingEventMask : uint16_t
 {
     kUnknown               = 0x1,
     kProgrammingPINChanged = 0x2,
     kPINAdded              = 0x4,
     kPINCleared            = 0x8,
     kPINChanged            = 0x10,
 };

 // Bitmap for DlLocalProgrammingFeatures
 enum class DlLocalProgrammingFeatures : uint8_t
 {
     kAddUsersCredentialsSchedulesLocally    = 0x1,
     kModifyUsersCredentialsSchedulesLocally = 0x2,
     kClearUsersCredentialsSchedulesLocally  = 0x4,
     kAdjustLockSettingsLocally              = 0x8,
 };

 // Bitmap for DlManualOperationEventMask
 enum class DlManualOperationEventMask : uint16_t
 {
     kUnknown         = 0x1,
     kThumbturnLock   = 0x2,
     kThumbturnUnlock = 0x4,
     kOneTouchLock    = 0x8,
     kKeyLock         = 0x10,
     kKeyUnlock       = 0x20,
     kAutoLock        = 0x40,
     kScheduleLock    = 0x80,
     kScheduleUnlock  = 0x100,
     kManualLock      = 0x200,
     kManualUnlock    = 0x400,
 };

 // Bitmap for DlRFIDOperationEventMask
 enum class DlRFIDOperationEventMask : uint16_t
 {
     kUnknown               = 0x1,
     kLock                  = 0x2,
     kUnlock                = 0x4,
     kLockInvalidRFID       = 0x8,
     kLockInvalidSchedule   = 0x10,
     kUnlockInvalidRFID     = 0x20,
     kUnlockInvalidSchedule = 0x40,
 };

 // Bitmap for DlRFIDProgrammingEventMask
 enum class DlRFIDProgrammingEventMask : uint16_t
 {
     kUnknown         = 0x1,
     kRFIDCodeAdded   = 0x20,
     kRFIDCodeCleared = 0x40,
 };

 // Bitmap for DlRemoteOperationEventMask
 enum class DlRemoteOperationEventMask : uint16_t
 {
     kUnknown               = 0x1,
     kLock                  = 0x2,
     kUnlock                = 0x4,
     kLockInvalidCode       = 0x8,
     kLockInvalidSchedule   = 0x10,
     kUnlockInvalidCode     = 0x20,
     kUnlockInvalidSchedule = 0x40,
 };

 // Bitmap for DlRemoteProgrammingEventMask
 enum class DlRemoteProgrammingEventMask : uint16_t
 {
     kUnknown               = 0x1,
     kProgrammingPINChanged = 0x2,
     kPINAdded              = 0x4,
     kPINCleared            = 0x8,
     kPINChanged            = 0x10,
     kRFIDCodeAdded         = 0x20,
     kRFIDCodeCleared       = 0x40,
 };

 // Bitmap for DlSupportedOperatingModes
 enum class DlSupportedOperatingModes : uint16_t
 {
     kNormal             = 0x1,
     kVacation           = 0x2,
     kPrivacy            = 0x4,
     kNoRemoteLockUnlock = 0x8,
     kPassage            = 0x10,
 };

 // Bitmap for DoorLockDayOfWeek
 enum class DoorLockDayOfWeek : uint8_t
 {
     kSunday    = 0x1,
     kMonday    = 0x2,
     kTuesday   = 0x4,
     kWednesday = 0x8,
     kThursday  = 0x10,
     kFriday    = 0x20,
     kSaturday  = 0x40,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kPinCredential               = 0x1,
     kRfidCredential              = 0x2,
     kFingerCredentials           = 0x4,
     kLogging                     = 0x8,
     kWeekDayAccessSchedules      = 0x10,
     kDoorPositionSensor          = 0x20,
     kFaceCredentials             = 0x40,
     kCredentialsOverTheAirAccess = 0x80,
     kUser                        = 0x100,
     kNotification                = 0x200,
     kYearDayAccessSchedules      = 0x400,
     kHolidaySchedules            = 0x800,
     kUnbolt                      = 0x1000,
 };
 } // namespace DoorLock

 namespace WindowCovering {

 // Enum for EndProductType
 enum class EndProductType : uint8_t
 {
     kRollerShade               = 0x00,
     kRomanShade                = 0x01,
     kBalloonShade              = 0x02,
     kWovenWood                 = 0x03,
     kPleatedShade              = 0x04,
     kCellularShade             = 0x05,
     kLayeredShade              = 0x06,
     kLayeredShade2D            = 0x07,
     kSheerShade                = 0x08,
     kTiltOnlyInteriorBlind     = 0x09,
     kInteriorBlind             = 0x0A,
     kVerticalBlindStripCurtain = 0x0B,
     kInteriorVenetianBlind     = 0x0C,
     kExteriorVenetianBlind     = 0x0D,
     kLateralLeftCurtain        = 0x0E,
     kLateralRightCurtain       = 0x0F,
     kCentralCurtain            = 0x10,
     kRollerShutter             = 0x11,
     kExteriorVerticalScreen    = 0x12,
     kAwningTerracePatio        = 0x13,
     kAwningVerticalScreen      = 0x14,
     kTiltOnlyPergola           = 0x15,
     kSwingingShutter           = 0x16,
     kSlidingShutter            = 0x17,
     kUnknown                   = 0xFF,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 24,
 };

 // Enum for Type
 enum class Type : uint8_t
 {
     kRollerShade               = 0x00,
     kRollerShade2Motor         = 0x01,
     kRollerShadeExterior       = 0x02,
     kRollerShadeExterior2Motor = 0x03,
     kDrapery                   = 0x04,
     kAwning                    = 0x05,
     kShutter                   = 0x06,
     kTiltBlindTiltOnly         = 0x07,
     kTiltBlindLiftAndTilt      = 0x08,
     kProjectorScreen           = 0x09,
     kUnknown                   = 0xFF,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 10,
 };

 // Bitmap for ConfigStatus
 enum class ConfigStatus : uint8_t
 {
     kOperational           = 0x1,
     kOnlineReserved        = 0x2,
     kLiftMovementReversed  = 0x4,
     kLiftPositionAware     = 0x8,
     kTiltPositionAware     = 0x10,
     kLiftEncoderControlled = 0x20,
     kTiltEncoderControlled = 0x40,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kLift              = 0x1,
     kTilt              = 0x2,
     kPositionAwareLift = 0x4,
     kAbsolutePosition  = 0x8,
     kPositionAwareTilt = 0x10,
 };

 // Bitmap for Mode
 enum class Mode : uint8_t
 {
     kMotorDirectionReversed = 0x1,
     kCalibrationMode        = 0x2,
     kMaintenanceMode        = 0x4,
     kLedFeedback            = 0x8,
 };

 // Bitmap for OperationalStatus
 enum class OperationalStatus : uint8_t
 {
     kGlobal = 0x3,
     kLift   = 0xC,
     kTilt   = 0x30,
 };

 // Bitmap for SafetyStatus
 enum class SafetyStatus : uint16_t
 {
     kRemoteLockout       = 0x1,
     kTamperDetection     = 0x2,
     kFailedCommunication = 0x4,
     kPositionFailure     = 0x8,
     kThermalProtection   = 0x10,
     kObstacleDetected    = 0x20,
     kPower               = 0x40,
     kStopInput           = 0x80,
     kMotorJammed         = 0x100,
     kHardwareFailure     = 0x200,
     kManualOperation     = 0x400,
     kProtection          = 0x800,
 };
 } // namespace WindowCovering

 namespace BarrierControl {} // namespace BarrierControl

 namespace PumpConfigurationAndControl {

 // Enum for ControlModeEnum
 enum class ControlModeEnum : uint8_t
 {
     kConstantSpeed        = 0x00,
     kConstantPressure     = 0x01,
     kProportionalPressure = 0x02,
     kConstantFlow         = 0x03,
     kConstantTemperature  = 0x05,
     kAutomatic            = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 4,
 };

 // Enum for OperationModeEnum
 enum class OperationModeEnum : uint8_t
 {
     kNormal  = 0x00,
     kMinimum = 0x01,
     kMaximum = 0x02,
     kLocal   = 0x03,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 4,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kConstantPressure    = 0x1,
     kCompensatedPressure = 0x2,
     kConstantFlow        = 0x4,
     kConstantSpeed       = 0x8,
     kConstantTemperature = 0x10,
     kAutomatic           = 0x20,
     kLocalOperation      = 0x40,
 };

 // Bitmap for PumpStatusBitmap
 enum class PumpStatusBitmap : uint16_t
 {
     kDeviceFault       = 0x1,
     kSupplyfault       = 0x2,
     kSpeedLow          = 0x4,
     kSpeedHigh         = 0x8,
     kLocalOverride     = 0x10,
     kRunning           = 0x20,
     kRemotePressure    = 0x40,
     kRemoteFlow        = 0x80,
     kRemoteTemperature = 0x100,
 };
 } // namespace PumpConfigurationAndControl

 namespace Thermostat {

 // Enum for SetpointAdjustMode
 enum class SetpointAdjustMode : uint8_t
 {
     kHeat = 0x00,
     kCool = 0x01,
     kBoth = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for ThermostatControlSequence
 enum class ThermostatControlSequence : uint8_t
 {
     kCoolingOnly                 = 0x00,
     kCoolingWithReheat           = 0x01,
     kHeatingOnly                 = 0x02,
     kHeatingWithReheat           = 0x03,
     kCoolingAndHeating           = 0x04,
     kCoolingAndHeatingWithReheat = 0x05,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 6,
 };

 // Enum for ThermostatRunningMode
 enum class ThermostatRunningMode : uint8_t
 {
     kOff  = 0x00,
     kCool = 0x03,
     kHeat = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 1,
 };

 // Enum for ThermostatSystemMode
 enum class ThermostatSystemMode : uint8_t
 {
     kOff           = 0x00,
     kAuto          = 0x01,
     kCool          = 0x03,
     kHeat          = 0x04,
     kEmergencyHeat = 0x05,
     kPrecooling    = 0x06,
     kFanOnly       = 0x07,
     kDry           = 0x08,
     kSleep         = 0x09,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };

 // Bitmap for DayOfWeek
 enum class DayOfWeek : uint8_t
 {
     kSunday    = 0x1,
     kMonday    = 0x2,
     kTuesday   = 0x4,
     kWednesday = 0x8,
     kThursday  = 0x10,
     kFriday    = 0x20,
     kSaturday  = 0x40,
     kAway      = 0x80,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kHeating                    = 0x1,
     kCooling                    = 0x2,
     kOccupancy                  = 0x4,
     kScheduleConfiguration      = 0x8,
     kSetback                    = 0x10,
     kAutoMode                   = 0x20,
     kLocalTemperatureNotExposed = 0x40,
 };

 // Bitmap for ModeForSequence
 enum class ModeForSequence : uint8_t
 {
     kHeatSetpointPresent = 0x1,
     kCoolSetpointPresent = 0x2,
 };
 } // namespace Thermostat

 namespace FanControl {

 // Enum for AirflowDirectionEnum
 enum class AirflowDirectionEnum : uint8_t
 {
     kForward = 0x00,
     kReverse = 0x01,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };

 // Enum for FanModeEnum
 enum class FanModeEnum : uint8_t
 {
     kOff    = 0x00,
     kLow    = 0x01,
     kMedium = 0x02,
     kHigh   = 0x03,
     kOn     = 0x04,
     kAuto   = 0x05,
     kSmart  = 0x06,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 7,
 };

 // Enum for FanModeSequenceEnum
 enum class FanModeSequenceEnum : uint8_t
 {
     kOffLowMedHigh     = 0x00,
     kOffLowHigh        = 0x01,
     kOffLowMedHighAuto = 0x02,
     kOffLowHighAuto    = 0x03,
     kOffOnAuto         = 0x04,
     kOffOn             = 0x05,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 6,
 };

 // Enum for StepDirectionEnum
 enum class StepDirectionEnum : uint8_t
 {
     kIncrease = 0x00,
     kDecrease = 0x01,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kMultiSpeed       = 0x1,
     kAuto             = 0x2,
     kRocking          = 0x4,
     kWind             = 0x8,
     kStep             = 0x10,
     kAirflowDirection = 0x20,
 };

 // Bitmap for RockBitmap
 enum class RockBitmap : uint8_t
 {
     kRockLeftRight = 0x1,
     kRockUpDown    = 0x2,
     kRockRound     = 0x4,
 };

 // Bitmap for WindBitmap
 enum class WindBitmap : uint8_t
 {
     kSleepWind   = 0x1,
     kNaturalWind = 0x2,
 };
 } // namespace FanControl

 namespace ThermostatUserInterfaceConfiguration {} // namespace ThermostatUserInterfaceConfiguration

 namespace ColorControl {

 // Enum for ColorLoopAction
 enum class ColorLoopAction : uint8_t
 {
     kDeactivate                            = 0x00,
     kActivateFromColorLoopStartEnhancedHue = 0x01,
     kActivateFromEnhancedCurrentHue        = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for ColorLoopDirection
 enum class ColorLoopDirection : uint8_t
 {
     kDecrementHue = 0x00,
     kIncrementHue = 0x01,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };

 // Need to convert consumers to using the new enum classes, so we
 // don't just have casts all over.
 #ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
 // Enum for ColorMode
 enum class ColorMode : uint8_t
 {
     kCurrentHueAndCurrentSaturation = 0x00,
     kCurrentXAndCurrentY            = 0x01,
     kColorTemperature               = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };
 #else  // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
 using ColorMode                                                      = EmberAfColorMode;
 static ColorMode __attribute__((unused)) kColorModekUnknownEnumValue = static_cast<ColorMode>(3);
 #endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM

 // Enum for HueDirection
 enum class HueDirection : uint8_t
 {
     kShortestDistance = 0x00,
     kLongestDistance  = 0x01,
     kUp               = 0x02,
     kDown             = 0x03,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 4,
 };

 // Enum for HueMoveMode
 enum class HueMoveMode : uint8_t
 {
     kStop = 0x00,
     kUp   = 0x01,
     kDown = 0x03,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };

 // Enum for HueStepMode
 enum class HueStepMode : uint8_t
 {
     kUp   = 0x01,
     kDown = 0x03,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 0,
 };

 // Enum for SaturationMoveMode
 enum class SaturationMoveMode : uint8_t
 {
     kStop = 0x00,
     kUp   = 0x01,
     kDown = 0x03,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };

 // Enum for SaturationStepMode
 enum class SaturationStepMode : uint8_t
 {
     kUp   = 0x01,
     kDown = 0x03,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 0,
 };

 // Bitmap for ColorCapabilities
 enum class ColorCapabilities : uint16_t
 {
     kHueSaturationSupported    = 0x1,
     kEnhancedHueSupported      = 0x2,
     kColorLoopSupported        = 0x4,
     kXYAttributesSupported     = 0x8,
     kColorTemperatureSupported = 0x10,
 };

 // Bitmap for ColorLoopUpdateFlags
 enum class ColorLoopUpdateFlags : uint8_t
 {
     kUpdateAction    = 0x1,
     kUpdateDirection = 0x2,
     kUpdateTime      = 0x4,
     kUpdateStartHue  = 0x8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kHueAndSaturation = 0x1,
     kEnhancedHue      = 0x2,
     kColorLoop        = 0x4,
     kXy               = 0x8,
     kColorTemperature = 0x10,
 };
 } // namespace ColorControl

 namespace BallastConfiguration {} // namespace BallastConfiguration

 namespace IlluminanceMeasurement {

 // Enum for LightSensorTypeEnum
 enum class LightSensorTypeEnum : uint8_t
 {
     kPhotodiode = 0x00,
     kCmos       = 0x01,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };
 } // namespace IlluminanceMeasurement

 namespace TemperatureMeasurement {} // namespace TemperatureMeasurement

 namespace PressureMeasurement {

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kExtended = 0x1,
 };
 } // namespace PressureMeasurement

 namespace FlowMeasurement {} // namespace FlowMeasurement

 namespace RelativeHumidityMeasurement {} // namespace RelativeHumidityMeasurement

 namespace OccupancySensing {

 // Enum for OccupancySensorTypeEnum
 enum class OccupancySensorTypeEnum : uint8_t
 {
     kPir              = 0x00,
     kUltrasonic       = 0x01,
     kPIRAndUltrasonic = 0x02,
     kPhysicalContact  = 0x03,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 4,
 };

 // Bitmap for OccupancyBitmap
 enum class OccupancyBitmap : uint8_t
 {
     kOccupied = 0x1,
 };

 // Bitmap for OccupancySensorTypeBitmap
 enum class OccupancySensorTypeBitmap : uint8_t
 {
     kPir             = 0x1,
     kUltrasonic      = 0x2,
     kPhysicalContact = 0x4,
 };
 } // namespace OccupancySensing

 namespace CarbonMonoxideConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace CarbonMonoxideConcentrationMeasurement

 namespace CarbonDioxideConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace CarbonDioxideConcentrationMeasurement

 namespace EthyleneConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace EthyleneConcentrationMeasurement

 namespace EthyleneOxideConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace EthyleneOxideConcentrationMeasurement

 namespace HydrogenConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace HydrogenConcentrationMeasurement

 namespace HydrogenSulfideConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace HydrogenSulfideConcentrationMeasurement

 namespace NitricOxideConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace NitricOxideConcentrationMeasurement

 namespace NitrogenDioxideConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace NitrogenDioxideConcentrationMeasurement

 namespace OxygenConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace OxygenConcentrationMeasurement

 namespace OzoneConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace OzoneConcentrationMeasurement

 namespace SulfurDioxideConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace SulfurDioxideConcentrationMeasurement

 namespace DissolvedOxygenConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace DissolvedOxygenConcentrationMeasurement

 namespace BromateConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace BromateConcentrationMeasurement

 namespace ChloraminesConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace ChloraminesConcentrationMeasurement

 namespace ChlorineConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace ChlorineConcentrationMeasurement

 namespace FecalColiformEColiConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace FecalColiformEColiConcentrationMeasurement

 namespace FluorideConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace FluorideConcentrationMeasurement

 namespace HaloaceticAcidsConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace HaloaceticAcidsConcentrationMeasurement

 namespace TotalTrihalomethanesConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace TotalTrihalomethanesConcentrationMeasurement

 namespace TotalColiformBacteriaConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace TotalColiformBacteriaConcentrationMeasurement

 namespace TurbidityConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace TurbidityConcentrationMeasurement

 namespace CopperConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace CopperConcentrationMeasurement

 namespace LeadConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace LeadConcentrationMeasurement

 namespace ManganeseConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace ManganeseConcentrationMeasurement

 namespace SulfateConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace SulfateConcentrationMeasurement

 namespace BromodichloromethaneConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace BromodichloromethaneConcentrationMeasurement

 namespace BromoformConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace BromoformConcentrationMeasurement

 namespace ChlorodibromomethaneConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace ChlorodibromomethaneConcentrationMeasurement

 namespace ChloroformConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace ChloroformConcentrationMeasurement

 namespace SodiumConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace SodiumConcentrationMeasurement

 namespace Pm25ConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace Pm25ConcentrationMeasurement

 namespace FormaldehydeConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace FormaldehydeConcentrationMeasurement

 namespace Pm1ConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace Pm1ConcentrationMeasurement

 namespace Pm10ConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace Pm10ConcentrationMeasurement

 namespace TotalVolatileOrganicCompoundsConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace TotalVolatileOrganicCompoundsConcentrationMeasurement

 namespace RadonConcentrationMeasurement {

 // Enum for LevelValueEnum
 enum class LevelValueEnum : uint8_t
 {
     kUnknown  = 0x00,
     kLow      = 0x01,
     kMedium   = 0x02,
     kHigh     = 0x03,
     kCritical = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };

 // Enum for MeasurementMediumEnum
 enum class MeasurementMediumEnum : uint8_t
 {
     kAir   = 0x00,
     kWater = 0x01,
     kSoil  = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MeasurementUnitEnum
 enum class MeasurementUnitEnum : uint8_t
 {
     kPpm  = 0x00,
     kPpb  = 0x01,
     kPpt  = 0x02,
     kMgm3 = 0x03,
     kUgm3 = 0x04,
     kNgm3 = 0x05,
     kPm3  = 0x06,
     kBqm3 = 0x07,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 8,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNumericMeasurement = 0x1,
     kLevelIndication    = 0x2,
     kMediumLevel        = 0x4,
     kCriticalLevel      = 0x8,
     kPeakMeasurement    = 0x10,
     kAverageMeasurement = 0x20,
 };
 } // namespace RadonConcentrationMeasurement

 namespace WakeOnLan {} // namespace WakeOnLan

 namespace Channel {

 // Enum for ChannelStatusEnum
 enum class ChannelStatusEnum : uint8_t
 {
     kSuccess         = 0x00,
     kMultipleMatches = 0x01,
     kNoMatches       = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for LineupInfoTypeEnum
 enum class LineupInfoTypeEnum : uint8_t
 {
     kMso = 0x00,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 1,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kChannelList = 0x1,
     kLineupInfo  = 0x2,
 };
 } // namespace Channel

 namespace TargetNavigator {

 // Enum for TargetNavigatorStatusEnum
 enum class TargetNavigatorStatusEnum : uint8_t
 {
     kSuccess        = 0x00,
     kTargetNotFound = 0x01,
     kNotAllowed     = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };
 } // namespace TargetNavigator

 namespace MediaPlayback {

 // Enum for MediaPlaybackStatusEnum
 enum class MediaPlaybackStatusEnum : uint8_t
 {
     kSuccess                = 0x00,
     kInvalidStateForCommand = 0x01,
     kNotAllowed             = 0x02,
     kNotActive              = 0x03,
     kSpeedOutOfRange        = 0x04,
     kSeekOutOfRange         = 0x05,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 6,
 };

 // Enum for PlaybackStateEnum
 enum class PlaybackStateEnum : uint8_t
 {
     kPlaying    = 0x00,
     kPaused     = 0x01,
     kNotPlaying = 0x02,
     kBuffering  = 0x03,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 4,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kAdvancedSeek  = 0x1,
     kVariableSpeed = 0x2,
 };
 } // namespace MediaPlayback

 namespace MediaInput {

 // Enum for InputTypeEnum
 enum class InputTypeEnum : uint8_t
 {
     kInternal  = 0x00,
     kAux       = 0x01,
     kCoax      = 0x02,
     kComposite = 0x03,
     kHdmi      = 0x04,
     kInput     = 0x05,
     kLine      = 0x06,
     kOptical   = 0x07,
     kVideo     = 0x08,
     kScart     = 0x09,
     kUsb       = 0x0A,
     kOther     = 0x0B,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 12,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNameUpdates = 0x1,
 };
 } // namespace MediaInput

 namespace LowPower {} // namespace LowPower

 namespace KeypadInput {

 // Enum for CecKeyCode
 enum class CecKeyCode : uint8_t
 {
     kSelect                    = 0x00,
     kUp                        = 0x01,
     kDown                      = 0x02,
     kLeft                      = 0x03,
     kRight                     = 0x04,
     kRightUp                   = 0x05,
     kRightDown                 = 0x06,
     kLeftUp                    = 0x07,
     kLeftDown                  = 0x08,
     kRootMenu                  = 0x09,
     kSetupMenu                 = 0x0A,
     kContentsMenu              = 0x0B,
     kFavoriteMenu              = 0x0C,
     kExit                      = 0x0D,
     kMediaTopMenu              = 0x10,
     kMediaContextSensitiveMenu = 0x11,
     kNumberEntryMode           = 0x1D,
     kNumber11                  = 0x1E,
     kNumber12                  = 0x1F,
     kNumber0OrNumber10         = 0x20,
     kNumbers1                  = 0x21,
     kNumbers2                  = 0x22,
     kNumbers3                  = 0x23,
     kNumbers4                  = 0x24,
     kNumbers5                  = 0x25,
     kNumbers6                  = 0x26,
     kNumbers7                  = 0x27,
     kNumbers8                  = 0x28,
     kNumbers9                  = 0x29,
     kDot                       = 0x2A,
     kEnter                     = 0x2B,
     kClear                     = 0x2C,
     kNextFavorite              = 0x2F,
     kChannelUp                 = 0x30,
     kChannelDown               = 0x31,
     kPreviousChannel           = 0x32,
     kSoundSelect               = 0x33,
     kInputSelect               = 0x34,
     kDisplayInformation        = 0x35,
     kHelp                      = 0x36,
     kPageUp                    = 0x37,
     kPageDown                  = 0x38,
     kPower                     = 0x40,
     kVolumeUp                  = 0x41,
     kVolumeDown                = 0x42,
     kMute                      = 0x43,
     kPlay                      = 0x44,
     kStop                      = 0x45,
     kPause                     = 0x46,
     kRecord                    = 0x47,
     kRewind                    = 0x48,
     kFastForward               = 0x49,
     kEject                     = 0x4A,
     kForward                   = 0x4B,
     kBackward                  = 0x4C,
     kStopRecord                = 0x4D,
     kPauseRecord               = 0x4E,
     kReserved                  = 0x4F,
     kAngle                     = 0x50,
     kSubPicture                = 0x51,
     kVideoOnDemand             = 0x52,
     kElectronicProgramGuide    = 0x53,
     kTimerProgramming          = 0x54,
     kInitialConfiguration      = 0x55,
     kSelectBroadcastType       = 0x56,
     kSelectSoundPresentation   = 0x57,
     kPlayFunction              = 0x60,
     kPausePlayFunction         = 0x61,
     kRecordFunction            = 0x62,
     kPauseRecordFunction       = 0x63,
     kStopFunction              = 0x64,
     kMuteFunction              = 0x65,
     kRestoreVolumeFunction     = 0x66,
     kTuneFunction              = 0x67,
     kSelectMediaFunction       = 0x68,
     kSelectAvInputFunction     = 0x69,
     kSelectAudioInputFunction  = 0x6A,
     kPowerToggleFunction       = 0x6B,
     kPowerOffFunction          = 0x6C,
     kPowerOnFunction           = 0x6D,
     kF1Blue                    = 0x71,
     kF2Red                     = 0x72,
     kF3Green                   = 0x73,
     kF4Yellow                  = 0x74,
     kF5                        = 0x75,
     kData                      = 0x76,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 14,
 };

 // Enum for KeypadInputStatusEnum
 enum class KeypadInputStatusEnum : uint8_t
 {
     kSuccess                  = 0x00,
     kUnsupportedKey           = 0x01,
     kInvalidKeyInCurrentState = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNavigationKeyCodes = 0x1,
     kLocationKeys       = 0x2,
     kNumberKeys         = 0x4,
 };
 } // namespace KeypadInput

 namespace ContentLauncher {

 // Enum for ContentLaunchStatusEnum
 enum class ContentLaunchStatusEnum : uint8_t
 {
     kSuccess         = 0x00,
     kUrlNotAvailable = 0x01,
     kAuthFailed      = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Enum for MetricTypeEnum
 enum class MetricTypeEnum : uint8_t
 {
     kPixels     = 0x00,
     kPercentage = 0x01,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 2,
 };

 // Enum for ParameterEnum
 enum class ParameterEnum : uint8_t
 {
     kActor      = 0x00,
     kChannel    = 0x01,
     kCharacter  = 0x02,
     kDirector   = 0x03,
     kEvent      = 0x04,
     kFranchise  = 0x05,
     kGenre      = 0x06,
     kLeague     = 0x07,
     kPopularity = 0x08,
     kProvider   = 0x09,
     kSport      = 0x0A,
     kSportsTeam = 0x0B,
     kType       = 0x0C,
     kVideo      = 0x0D,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 14,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kContentSearch = 0x1,
     kURLPlayback   = 0x2,
 };

 // Bitmap for SupportedStreamingProtocol
 enum class SupportedStreamingProtocol : uint32_t
 {
     kDash = 0x1,
     kHls  = 0x2,
 };
 } // namespace ContentLauncher

 namespace AudioOutput {

 // Enum for OutputTypeEnum
 enum class OutputTypeEnum : uint8_t
 {
     kHdmi      = 0x00,
     kBt        = 0x01,
     kOptical   = 0x02,
     kHeadphone = 0x03,
     kInternal  = 0x04,
     kOther     = 0x05,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 6,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNameUpdates = 0x1,
 };
 } // namespace AudioOutput

 namespace ApplicationLauncher {

 // Enum for ApplicationLauncherStatusEnum
 enum class ApplicationLauncherStatusEnum : uint8_t
 {
     kSuccess         = 0x00,
     kAppNotAvailable = 0x01,
     kSystemBusy      = 0x02,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 3,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kApplicationPlatform = 0x1,
 };
 } // namespace ApplicationLauncher

 namespace ApplicationBasic {

 // Enum for ApplicationStatusEnum
 enum class ApplicationStatusEnum : uint8_t
 {
     kStopped               = 0x00,
     kActiveVisibleFocus    = 0x01,
     kActiveHidden          = 0x02,
     kActiveVisibleNotFocus = 0x03,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 4,
 };
 } // namespace ApplicationBasic

 namespace AccountLogin {} // namespace AccountLogin

 namespace ElectricalMeasurement {} // namespace ElectricalMeasurement

 namespace UnitTesting {

 // Enum for SimpleEnum
 enum class SimpleEnum : uint8_t
 {
     kUnspecified = 0x00,
     kValueA      = 0x01,
     kValueB      = 0x02,
     kValueC      = 0x03,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 4,
 };

 // Bitmap for Bitmap16MaskMap
 enum class Bitmap16MaskMap : uint16_t
 {
     kMaskVal1 = 0x1,
     kMaskVal2 = 0x2,
     kMaskVal3 = 0x4,
     kMaskVal4 = 0x4000,
 };

 // Bitmap for Bitmap32MaskMap
 enum class Bitmap32MaskMap : uint32_t
 {
     kMaskVal1 = 0x1,
     kMaskVal2 = 0x2,
     kMaskVal3 = 0x4,
     kMaskVal4 = 0x40000000,
 };

 // Bitmap for Bitmap64MaskMap
 enum class Bitmap64MaskMap : uint64_t
 {
     kMaskVal1 = 0x1,
     kMaskVal2 = 0x2,
     kMaskVal3 = 0x4,
     kMaskVal4 = 0x4000000000000000,
 };

 // Bitmap for Bitmap8MaskMap
 enum class Bitmap8MaskMap : uint8_t
 {
     kMaskVal1 = 0x1,
     kMaskVal2 = 0x2,
     kMaskVal3 = 0x4,
     kMaskVal4 = 0x40,
 };

 // Bitmap for SimpleBitmap
 enum class SimpleBitmap : uint8_t
 {
     kValueA = 0x1,
     kValueB = 0x2,
     kValueC = 0x4,
 };
 } // namespace UnitTesting

 namespace FaultInjection {

 // Enum for FaultType
 enum class FaultType : uint8_t
 {
     kUnspecified = 0x00,
     kSystemFault = 0x01,
     kInetFault   = 0x02,
     kChipFault   = 0x03,
     kCertFault   = 0x04,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 5,
 };
 } // namespace FaultInjection

 } // namespace Clusters
 } // namespace app
 } // namespace chip