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>

 namespace chip {
 namespace app {
 namespace Clusters {

 namespace detail {
 // Enums shared across multiple clusters.

 // 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 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 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 MeasurementTypeEnum
 enum class MeasurementTypeEnum : uint16_t
 {
     kUnspecified      = 0x00,
     kVoltage          = 0x01,
     kActiveCurrent    = 0x02,
     kReactiveCurrent  = 0x03,
     kApparentCurrent  = 0x04,
     kActivePower      = 0x05,
     kReactivePower    = 0x06,
     kApparentPower    = 0x07,
     kRMSVoltage       = 0x08,
     kRMSCurrent       = 0x09,
     kRMSPower         = 0x0A,
     kFrequency        = 0x0B,
     kPowerFactor      = 0x0C,
     kNeutralCurrent   = 0x0D,
     kElectricalEnergy = 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 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,
 };

 // 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,
 };

 // 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,
 };

 // Bitmaps shared across multiple clusters.

 } // namespace detail

 namespace Globals {
 // Global enums.

 // Enum for AreaTypeTag
 enum class AreaTypeTag : uint8_t
 {
     kAisle           = 0x00,
     kAttic           = 0x01,
     kBackDoor        = 0x02,
     kBackYard        = 0x03,
     kBalcony         = 0x04,
     kBallroom        = 0x05,
     kBathroom        = 0x06,
     kBedroom         = 0x07,
     kBorder          = 0x08,
     kBoxroom         = 0x09,
     kBreakfastRoom   = 0x0A,
     kCarport         = 0x0B,
     kCellar          = 0x0C,
     kCloakroom       = 0x0D,
     kCloset          = 0x0E,
     kConservatory    = 0x0F,
     kCorridor        = 0x10,
     kCraftRoom       = 0x11,
     kCupboard        = 0x12,
     kDeck            = 0x13,
     kDen             = 0x14,
     kDining          = 0x15,
     kDrawingRoom     = 0x16,
     kDressingRoom    = 0x17,
     kDriveway        = 0x18,
     kElevator        = 0x19,
     kEnsuite         = 0x1A,
     kEntrance        = 0x1B,
     kEntryway        = 0x1C,
     kFamilyRoom      = 0x1D,
     kFoyer           = 0x1E,
     kFrontDoor       = 0x1F,
     kFrontYard       = 0x20,
     kGameRoom        = 0x21,
     kGarage          = 0x22,
     kGarageDoor      = 0x23,
     kGarden          = 0x24,
     kGardenDoor      = 0x25,
     kGuestBathroom   = 0x26,
     kGuestBedroom    = 0x27,
     kGuestRestroom   = 0x28,
     kGuestRoom       = 0x29,
     kGym             = 0x2A,
     kHallway         = 0x2B,
     kHearthRoom      = 0x2C,
     kKidsRoom        = 0x2D,
     kKidsBedroom     = 0x2E,
     kKitchen         = 0x2F,
     kLarder          = 0x30,
     kLaundryRoom     = 0x31,
     kLawn            = 0x32,
     kLibrary         = 0x33,
     kLivingRoom      = 0x34,
     kLounge          = 0x35,
     kMediaTvRoom     = 0x36,
     kMudRoom         = 0x37,
     kMusicRoom       = 0x38,
     kNursery         = 0x39,
     kOffice          = 0x3A,
     kOutdoorKitchen  = 0x3B,
     kOutside         = 0x3C,
     kPantry          = 0x3D,
     kParkingLot      = 0x3E,
     kParlor          = 0x3F,
     kPatio           = 0x40,
     kPlayRoom        = 0x41,
     kPoolRoom        = 0x42,
     kPorch           = 0x43,
     kPrimaryBathroom = 0x44,
     kPrimaryBedroom  = 0x45,
     kRamp            = 0x46,
     kReceptionRoom   = 0x47,
     kRecreationRoom  = 0x48,
     kRestroom        = 0x49,
     kRoof            = 0x4A,
     kSauna           = 0x4B,
     kScullery        = 0x4C,
     kSewingRoom      = 0x4D,
     kShed            = 0x4E,
     kSideDoor        = 0x4F,
     kSideYard        = 0x50,
     kSittingRoom     = 0x51,
     kSnug            = 0x52,
     kSpa             = 0x53,
     kStaircase       = 0x54,
     kSteamRoom       = 0x55,
     kStorageRoom     = 0x56,
     kStudio          = 0x57,
     kStudy           = 0x58,
     kSunRoom         = 0x59,
     kSwimmingPool    = 0x5A,
     kTerrace         = 0x5B,
     kUtilityRoom     = 0x5C,
     kWard            = 0x5D,
     kWorkshop        = 0x5E,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 95,
 };

 // Enum for AtomicRequestTypeEnum
 enum class AtomicRequestTypeEnum : uint8_t
 {
     kBeginWrite    = 0x00,
     kCommitWrite   = 0x01,
     kRollbackWrite = 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 FloorSurfaceTag
 enum class FloorSurfaceTag : uint8_t
 {
     kCarpet           = 0x00,
     kCeramic          = 0x01,
     kConcrete         = 0x02,
     kCork             = 0x03,
     kDeepCarpet       = 0x04,
     kDirt             = 0x05,
     kEngineeredWood   = 0x06,
     kGlass            = 0x07,
     kGrass            = 0x08,
     kHardwood         = 0x09,
     kLaminate         = 0x0A,
     kLinoleum         = 0x0B,
     kMat              = 0x0C,
     kMetal            = 0x0D,
     kPlastic          = 0x0E,
     kPolishedConcrete = 0x0F,
     kRubber           = 0x10,
     kRug              = 0x11,
     kSand             = 0x12,
     kStone            = 0x13,
     kTatami           = 0x14,
     kTerrazzo         = 0x15,
     kTile             = 0x16,
     kVinyl            = 0x17,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value 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 LandmarkTag
 enum class LandmarkTag : uint8_t
 {
     kAirConditioner = 0x00,
     kAirPurifier    = 0x01,
     kBackDoor       = 0x02,
     kBarStool       = 0x03,
     kBathMat        = 0x04,
     kBathtub        = 0x05,
     kBed            = 0x06,
     kBookshelf      = 0x07,
     kChair          = 0x08,
     kChristmasTree  = 0x09,
     kCoatRack       = 0x0A,
     kCoffeeTable    = 0x0B,
     kCookingRange   = 0x0C,
     kCouch          = 0x0D,
     kCountertop     = 0x0E,
     kCradle         = 0x0F,
     kCrib           = 0x10,
     kDesk           = 0x11,
     kDiningTable    = 0x12,
     kDishwasher     = 0x13,
     kDoor           = 0x14,
     kDresser        = 0x15,
     kLaundryDryer   = 0x16,
     kFan            = 0x17,
     kFireplace      = 0x18,
     kFreezer        = 0x19,
     kFrontDoor      = 0x1A,
     kHighChair      = 0x1B,
     kKitchenIsland  = 0x1C,
     kLamp           = 0x1D,
     kLitterBox      = 0x1E,
     kMirror         = 0x1F,
     kNightstand     = 0x20,
     kOven           = 0x21,
     kPetBed         = 0x22,
     kPetBowl        = 0x23,
     kPetCrate       = 0x24,
     kRefrigerator   = 0x25,
     kScratchingPost = 0x26,
     kShoeRack       = 0x27,
     kShower         = 0x28,
     kSideDoor       = 0x29,
     kSink           = 0x2A,
     kSofa           = 0x2B,
     kStove          = 0x2C,
     kTable          = 0x2D,
     kToilet         = 0x2E,
     kTrashCan       = 0x2F,
     kLaundryWasher  = 0x30,
     kWindow         = 0x31,
     kWineCooler     = 0x32,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 51,
 };

 // Enum for PositionTag
 enum class PositionTag : uint8_t
 {
     kLeft   = 0x00,
     kRight  = 0x01,
     kTop    = 0x02,
     kBottom = 0x03,
     kMiddle = 0x04,
     kRow    = 0x05,
     kColumn = 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 RelativePositionTag
 enum class RelativePositionTag : uint8_t
 {
     kUnder   = 0x00,
     kNextTo  = 0x01,
     kAround  = 0x02,
     kOn      = 0x03,
     kAbove   = 0x04,
     kFrontOf = 0x05,
     kBehind  = 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 TestGlobalEnum
 enum class TestGlobalEnum : uint8_t
 {
     kSomeValue      = 0x00,
     kSomeOtherValue = 0x01,
     kFinalValue     = 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,
 };

 // Global bitmaps.

 // Bitmap for TestGlobalBitmap
 enum class TestGlobalBitmap : uint32_t
 {
     kFirstBit  = 0x1,
     kSecondBit = 0x2,
 };

 } // namespace Globals

 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 OnOff {

 // Enum for DelayedAllOffEffectVariantEnum
 enum class DelayedAllOffEffectVariantEnum : uint8_t
 {
     kDelayedOffFastFade = 0x00,
     kNoFade             = 0x01,
     kDelayedOffSlowFade = 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 DyingLightEffectVariantEnum
 enum class DyingLightEffectVariantEnum : uint8_t
 {
     kDyingLightFadeOff = 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 EffectIdentifierEnum
 enum class EffectIdentifierEnum : 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 StartUpOnOffEnum
 enum class StartUpOnOffEnum : uint8_t
 {
     kOff    = 0x00,
     kOn     = 0x01,
     kToggle = 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,
     kDeadFrontBehavior = 0x2,
     kOffOnly           = 0x4,
 };

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

 namespace OnOffSwitchConfiguration {} // namespace OnOffSwitchConfiguration

 namespace LevelControl {

 // Enum for MoveModeEnum
 enum class MoveModeEnum : 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 StepModeEnum
 enum class StepModeEnum : 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,
 };

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

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

 namespace BinaryInputBasic {} // namespace BinaryInputBasic

 namespace PulseWidthModulation {} // namespace PulseWidthModulation

 namespace Descriptor {

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kTagList = 0x1,
 };
 } // 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 AccessRestrictionTypeEnum
 enum class AccessRestrictionTypeEnum : uint8_t
 {
     kAttributeAccessForbidden = 0x00,
     kAttributeWriteForbidden  = 0x01,
     kCommandForbidden         = 0x02,
     kEventForbidden           = 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 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,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kExtension     = 0x1,
     kManagedDevice = 0x2,
 };
 } // 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 ApplyUpdateActionEnum
 enum class ApplyUpdateActionEnum : 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 DownloadProtocolEnum
 enum class DownloadProtocolEnum : 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 StatusEnum
 enum class StatusEnum : 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 AnnouncementReasonEnum
 enum class AnnouncementReasonEnum : 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 ChangeReasonEnum
 enum class ChangeReasonEnum : 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 UpdateStateEnum
 enum class UpdateStateEnum : 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,
     kUseActiveLocale = 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 = 12,
 };

 // Enum for HourFormatEnum
 enum class HourFormatEnum : uint8_t
 {
     k12hr            = 0x00,
     k24hr            = 0x01,
     kUseActiveLocale = 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,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kCalendarFormat = 0x1,
 };
 } // 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,
     kRequiredTCNotAccepted         = 0x05,
     kTCAcknowledgementsNotReceived = 0x06,
     kTCMinVersionNotMet            = 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,
 };

 // 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,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kTermsAndConditions = 0x1,
 };
 } // 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,
     kPerDeviceCredentials     = 0x8,
 };

 // Bitmap for ThreadCapabilitiesBitmap
 enum class ThreadCapabilitiesBitmap : uint16_t
 {
     kIsBorderRouterCapable                = 0x1,
     kIsRouterCapable                      = 0x2,
     kIsSleepyEndDeviceCapable             = 0x4,
     kIsFullThreadDevice                   = 0x8,
     kIsSynchronizedSleepyEndDeviceCapable = 0x10,
 };

 // Bitmap for WiFiSecurityBitmap
 enum class WiFiSecurityBitmap : uint8_t
 {
     kUnencrypted   = 0x1,
     kWep           = 0x2,
     kWpaPersonal   = 0x4,
     kWpa2Personal  = 0x8,
     kWpa3Personal  = 0x10,
     kWpa3MatterPdc = 0x20,
 };
 } // 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,
 };

 // 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,
 };

 // 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,
 };

 // 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,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kDataModelTest = 0x1,
 };
 } // 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 {

 // 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,
 };

 // 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,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kBridgedICDSupport = 0x100000,
 };
 } // namespace BridgedDeviceBasicInformation

 namespace Switch {

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kLatchingSwitch            = 0x1,
     kMomentarySwitch           = 0x2,
     kMomentarySwitchRelease    = 0x4,
     kMomentarySwitchLongPress  = 0x8,
     kMomentarySwitchMultiPress = 0x10,
     kActionSwitch              = 0x20,
 };
 } // 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,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kBasic = 0x1,
 };
 } // 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,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kCacheAndSync = 0x1,
 };
 } // 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 {

 // Enum for ClientTypeEnum
 enum class ClientTypeEnum : uint8_t
 {
     kPermanent = 0x00,
     kEphemeral = 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 OperatingModeEnum
 enum class OperatingModeEnum : uint8_t
 {
     kSit = 0x00,
     kLit = 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
 {
     kCheckInProtocolSupport = 0x1,
     kUserActiveModeTrigger  = 0x2,
     kLongIdleTimeSupport    = 0x4,
     kDynamicSitLitSupport   = 0x8,
 };

 // Bitmap for UserActiveModeTriggerBitmap
 enum class UserActiveModeTriggerBitmap : uint32_t
 {
     kPowerCycle               = 0x1,
     kSettingsMenu             = 0x2,
     kCustomInstruction        = 0x4,
     kDeviceManual             = 0x8,
     kActuateSensor            = 0x10,
     kActuateSensorSeconds     = 0x20,
     kActuateSensorTimes       = 0x40,
     kActuateSensorLightsBlink = 0x80,
     kResetButton              = 0x100,
     kResetButtonLightsBlink   = 0x200,
     kResetButtonSeconds       = 0x400,
     kResetButtonTimes         = 0x800,
     kSetupButton              = 0x1000,
     kSetupButtonSeconds       = 0x2000,
     kSetupButtonLightsBlink   = 0x4000,
     kSetupButtonTimes         = 0x8000,
     kAppDefinedButton         = 0x10000,
 };
 } // namespace IcdManagement

 namespace Timer {

 // Enum for TimerStatusEnum
 enum class TimerStatusEnum : uint8_t
 {
     kRunning = 0x00,
     kPaused  = 0x01,
     kExpired = 0x02,
     kReady   = 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
 {
     kReset = 0x1,
 };
 } // namespace Timer

 namespace OvenCavityOperationalState {

 using ErrorStateEnum = Clusters::detail::ErrorStateEnum;

 using OperationalStateEnum = Clusters::detail::OperationalStateEnum;
 } // namespace OvenCavityOperationalState

 namespace OvenMode {

 // Enum for ModeTag
 enum class ModeTag : uint16_t
 {
     kBake            = 0x4000,
     kConvection      = 0x4001,
     kGrill           = 0x4002,
     kRoast           = 0x4003,
     kClean           = 0x4004,
     kConvectionBake  = 0x4005,
     kConvectionRoast = 0x4006,
     kWarming         = 0x4007,
     kProofing        = 0x4008,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value 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 OvenMode

 namespace LaundryDryerControls {

 // Enum for DrynessLevelEnum
 enum class DrynessLevelEnum : uint8_t
 {
     kLow    = 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,
 };
 } // namespace LaundryDryerControls

 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,
     // kUnknownEnumValue intentionally not defined. This enum never goes
     // through DataModel::Decode, likely because it is a part of a derived
     // cluster. As a result having kUnknownEnumValue in this enum is error
     // prone, and was removed. See
     // src/app/common/templates/config-data.yaml.
 };

 // 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,
     // kUnknownEnumValue intentionally not defined. This enum never goes
     // through DataModel::Decode, likely because it is a part of a derived
     // cluster. As a result having kUnknownEnumValue in this enum is error
     // prone, and was removed. See
     // src/app/common/templates/config-data.yaml.
 };

 // 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,
     kMapping  = 0x4002,
     // kUnknownEnumValue intentionally not defined. This enum never goes
     // through DataModel::Decode, likely because it is a part of a derived
     // cluster. As a result having kUnknownEnumValue in this enum is error
     // prone, and was removed. See
     // src/app/common/templates/config-data.yaml.
 };

 // Enum for StatusCode
 enum class StatusCode : uint8_t
 {
     kStuck                 = 0x41,
     kDustBinMissing        = 0x42,
     kDustBinFull           = 0x43,
     kWaterTankEmpty        = 0x44,
     kWaterTankMissing      = 0x45,
     kWaterTankLidOpen      = 0x46,
     kMopCleaningPadMissing = 0x47,
     kBatteryLow            = 0x48,
     // kUnknownEnumValue intentionally not defined. This enum never goes
     // through DataModel::Decode, likely because it is a part of a derived
     // cluster. As a result having kUnknownEnumValue in this enum is error
     // prone, and was removed. See
     // src/app/common/templates/config-data.yaml.
 };

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

 namespace RvcCleanMode {

 // Enum for ModeTag
 enum class ModeTag : uint16_t
 {
     kDeepClean = 0x4000,
     kVacuum    = 0x4001,
     kMop       = 0x4002,
     // kUnknownEnumValue intentionally not defined. This enum never goes
     // through DataModel::Decode, likely because it is a part of a derived
     // cluster. As a result having kUnknownEnumValue in this enum is error
     // prone, and was removed. See
     // src/app/common/templates/config-data.yaml.
 };

 // Enum for StatusCode
 enum class StatusCode : uint8_t
 {
     kCleaningInProgress = 0x40,
     // kUnknownEnumValue intentionally not defined. This enum never goes
     // through DataModel::Decode, likely because it is a part of a derived
     // cluster. As a result having kUnknownEnumValue in this enum is error
     // prone, and was removed. See
     // src/app/common/templates/config-data.yaml.
 };

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

 namespace TemperatureControl {

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

 namespace RefrigeratorAlarm {

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

 namespace DishwasherMode {

 // Enum for ModeTag
 enum class ModeTag : uint16_t
 {
     kNormal = 0x4000,
     kHeavy  = 0x4001,
     kLight  = 0x4002,
     // kUnknownEnumValue intentionally not defined. This enum never goes
     // through DataModel::Decode, likely because it is a part of a derived
     // cluster. As a result having kUnknownEnumValue in this enum is error
     // prone, and was removed. See
     // src/app/common/templates/config-data.yaml.
 };

 // 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 AlarmBitmap
 enum class AlarmBitmap : uint32_t
 {
     kInflowError     = 0x1,
     kDrainError      = 0x2,
     kDoorError       = 0x4,
     kTempTooLow      = 0x8,
     kTempTooHigh     = 0x10,
     kWaterLevelError = 0x20,
 };

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

 namespace MicrowaveOvenMode {

 // Enum for ModeTag
 enum class ModeTag : uint16_t
 {
     kNormal  = 0x4000,
     kDefrost = 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 MicrowaveOvenMode

 namespace MicrowaveOvenControl {

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kPowerAsNumber     = 0x1,
     kPowerInWatts      = 0x2,
     kPowerNumberLimits = 0x4,
 };
 } // namespace MicrowaveOvenControl

 namespace OperationalState {

 using ErrorStateEnum = Clusters::detail::ErrorStateEnum;

 using OperationalStateEnum = Clusters::detail::OperationalStateEnum;
 } // 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,
     // kUnknownEnumValue intentionally not defined. This enum never goes
     // through DataModel::Decode, likely because it is a part of a derived
     // cluster. As a result having kUnknownEnumValue in this enum is error
     // prone, and was removed. See
     // src/app/common/templates/config-data.yaml.
 };

 // Enum for OperationalStateEnum
 enum class OperationalStateEnum : uint8_t
 {
     kSeekingCharger = 0x40,
     kCharging       = 0x41,
     kDocked         = 0x42,
     // kUnknownEnumValue intentionally not defined. This enum never goes
     // through DataModel::Decode, likely because it is a part of a derived
     // cluster. As a result having kUnknownEnumValue in this enum is error
     // prone, and was removed. See
     // src/app/common/templates/config-data.yaml.
 };
 } // namespace RvcOperationalState

 namespace ScenesManagement {

 // Bitmap for CopyModeBitmap
 enum class CopyModeBitmap : uint8_t
 {
     kCopyAllScenes = 0x1,
 };

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

 namespace HepaFilterMonitoring {

 using ChangeIndicationEnum = Clusters::detail::ChangeIndicationEnum;

 using DegradationDirectionEnum = Clusters::detail::DegradationDirectionEnum;

 using ProductIdentifierTypeEnum = Clusters::detail::ProductIdentifierTypeEnum;

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

 namespace ActivatedCarbonFilterMonitoring {

 using ChangeIndicationEnum = Clusters::detail::ChangeIndicationEnum;

 using DegradationDirectionEnum = Clusters::detail::DegradationDirectionEnum;

 using ProductIdentifierTypeEnum = Clusters::detail::ProductIdentifierTypeEnum;

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

 namespace BooleanStateConfiguration {

 // Bitmap for AlarmModeBitmap
 enum class AlarmModeBitmap : uint8_t
 {
     kVisual  = 0x1,
     kAudible = 0x2,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kVisual           = 0x1,
     kAudible          = 0x2,
     kAlarmSuppress    = 0x4,
     kSensitivityLevel = 0x8,
 };

 // Bitmap for SensorFaultBitmap
 enum class SensorFaultBitmap : uint16_t
 {
     kGeneralFault = 0x1,
 };
 } // namespace BooleanStateConfiguration

 namespace ValveConfigurationAndControl {

 // Enum for StatusCodeEnum
 enum class StatusCodeEnum : uint8_t
 {
     kFailureDueToFault = 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 ValveStateEnum
 enum class ValveStateEnum : uint8_t
 {
     kClosed        = 0x00,
     kOpen          = 0x01,
     kTransitioning = 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
 {
     kTimeSync = 0x1,
     kLevel    = 0x2,
 };

 // Bitmap for ValveFaultBitmap
 enum class ValveFaultBitmap : uint16_t
 {
     kGeneralFault    = 0x1,
     kBlocked         = 0x2,
     kLeaking         = 0x4,
     kNotConnected    = 0x8,
     kShortCircuit    = 0x10,
     kCurrentExceeded = 0x20,
 };
 } // namespace ValveConfigurationAndControl

 namespace ElectricalPowerMeasurement {

 using MeasurementTypeEnum = Clusters::detail::MeasurementTypeEnum;

 // Enum for PowerModeEnum
 enum class PowerModeEnum : uint8_t
 {
     kUnknown = 0x00,
     kDc      = 0x01,
     kAc      = 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
 {
     kDirectCurrent      = 0x1,
     kAlternatingCurrent = 0x2,
     kPolyphasePower     = 0x4,
     kHarmonics          = 0x8,
     kPowerQuality       = 0x10,
 };
 } // namespace ElectricalPowerMeasurement

 namespace ElectricalEnergyMeasurement {

 using MeasurementTypeEnum = Clusters::detail::MeasurementTypeEnum;

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kImportedEnergy   = 0x1,
     kExportedEnergy   = 0x2,
     kCumulativeEnergy = 0x4,
     kPeriodicEnergy   = 0x8,
 };
 } // namespace ElectricalEnergyMeasurement

 namespace WaterHeaterManagement {

 // Enum for BoostStateEnum
 enum class BoostStateEnum : uint8_t
 {
     kInactive = 0x00,
     kActive   = 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
 {
     kEnergyManagement = 0x1,
     kTankPercent      = 0x2,
 };

 // Bitmap for WaterHeaterHeatSourceBitmap
 enum class WaterHeaterHeatSourceBitmap : uint8_t
 {
     kImmersionElement1 = 0x1,
     kImmersionElement2 = 0x2,
     kHeatPump          = 0x4,
     kBoiler            = 0x8,
     kOther             = 0x10,
 };
 } // namespace WaterHeaterManagement

 namespace DemandResponseLoadControl {

 // Enum for CriticalityLevelEnum
 enum class CriticalityLevelEnum : uint8_t
 {
     kUnknown           = 0x00,
     kGreen             = 0x01,
     kLevel1            = 0x02,
     kLevel2            = 0x03,
     kLevel3            = 0x04,
     kLevel4            = 0x05,
     kLevel5            = 0x06,
     kEmergency         = 0x07,
     kPlannedOutage     = 0x08,
     kServiceDisconnect = 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 HeatingSourceEnum
 enum class HeatingSourceEnum : uint8_t
 {
     kAny         = 0x00,
     kElectric    = 0x01,
     kNonElectric = 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 LoadControlEventChangeSourceEnum
 enum class LoadControlEventChangeSourceEnum : uint8_t
 {
     kAutomatic  = 0x00,
     kUserAction = 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 LoadControlEventStatusEnum
 enum class LoadControlEventStatusEnum : uint8_t
 {
     kUnknown         = 0x00,
     kReceived        = 0x01,
     kInProgress      = 0x02,
     kCompleted       = 0x03,
     kOptedOut        = 0x04,
     kOptedIn         = 0x05,
     kCanceled        = 0x06,
     kSuperseded      = 0x07,
     kPartialOptedOut = 0x08,
     kPartialOptedIn  = 0x09,
     kNoParticipation = 0x0A,
     kUnavailable     = 0x0B,
     kFailed          = 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,
 };

 // Bitmap for CancelControlBitmap
 enum class CancelControlBitmap : uint16_t
 {
     kRandomEnd = 0x1,
 };

 // Bitmap for DeviceClassBitmap
 enum class DeviceClassBitmap : uint32_t
 {
     kHvac             = 0x1,
     kStripHeater      = 0x2,
     kWaterHeater      = 0x4,
     kPoolPump         = 0x8,
     kSmartAppliance   = 0x10,
     kIrrigationPump   = 0x20,
     kCommercialLoad   = 0x40,
     kResidentialLoad  = 0x80,
     kExteriorLighting = 0x100,
     kInteriorLighting = 0x200,
     kEv               = 0x400,
     kGenerationSystem = 0x800,
     kSmartInverter    = 0x1000,
     kEvse             = 0x2000,
     kResu             = 0x4000,
     kEms              = 0x8000,
     kSem              = 0x10000,
 };

 // Bitmap for EventControlBitmap
 enum class EventControlBitmap : uint16_t
 {
     kRandomStart = 0x1,
 };

 // Bitmap for EventTransitionControlBitmap
 enum class EventTransitionControlBitmap : uint16_t
 {
     kRandomDuration = 0x1,
     kIgnoreOptOut   = 0x2,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kEnrollmentGroups    = 0x1,
     kTemperatureOffset   = 0x2,
     kTemperatureSetpoint = 0x4,
     kLoadAdjustment      = 0x8,
     kDutyCycle           = 0x10,
     kPowerSavings        = 0x20,
     kHeatingSource       = 0x40,
 };
 } // namespace DemandResponseLoadControl

 namespace Messages {

 // Enum for FutureMessagePreferenceEnum
 enum class FutureMessagePreferenceEnum : uint8_t
 {
     kAllowed    = 0x00,
     kIncreased  = 0x01,
     kReduced    = 0x02,
     kDisallowed = 0x03,
     kBanned     = 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 MessagePriorityEnum
 enum class MessagePriorityEnum : uint8_t
 {
     kLow      = 0x00,
     kMedium   = 0x01,
     kHigh     = 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,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kReceivedConfirmation = 0x1,
     kConfirmationResponse = 0x2,
     kConfirmationReply    = 0x4,
     kProtectedMessages    = 0x8,
 };

 // Bitmap for MessageControlBitmap
 enum class MessageControlBitmap : uint8_t
 {
     kConfirmationRequired = 0x1,
     kResponseRequired     = 0x2,
     kReplyMessage         = 0x4,
     kMessageConfirmed     = 0x8,
     kMessageProtected     = 0x10,
 };
 } // namespace Messages

 namespace DeviceEnergyManagement {

 // Enum for AdjustmentCauseEnum
 enum class AdjustmentCauseEnum : uint8_t
 {
     kLocalOptimization = 0x00,
     kGridOptimization  = 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 CauseEnum
 enum class CauseEnum : uint8_t
 {
     kNormalCompletion = 0x00,
     kOffline          = 0x01,
     kFault            = 0x02,
     kUserOptOut       = 0x03,
     kCancelled        = 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 CostTypeEnum
 enum class CostTypeEnum : uint8_t
 {
     kFinancial    = 0x00,
     kGHGEmissions = 0x01,
     kComfort      = 0x02,
     kTemperature  = 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 ESAStateEnum
 enum class ESAStateEnum : uint8_t
 {
     kOffline           = 0x00,
     kOnline            = 0x01,
     kFault             = 0x02,
     kPowerAdjustActive = 0x03,
     kPaused            = 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 ESATypeEnum
 enum class ESATypeEnum : uint8_t
 {
     kEvse                = 0x00,
     kSpaceHeating        = 0x01,
     kWaterHeating        = 0x02,
     kSpaceCooling        = 0x03,
     kSpaceHeatingCooling = 0x04,
     kBatteryStorage      = 0x05,
     kSolarPV             = 0x06,
     kFridgeFreezer       = 0x07,
     kWashingMachine      = 0x08,
     kDishwasher          = 0x09,
     kCooking             = 0x0A,
     kHomeWaterPump       = 0x0B,
     kIrrigationWaterPump = 0x0C,
     kPoolPump            = 0x0D,
     kOther               = 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 = 14,
 };

 // Enum for ForecastUpdateReasonEnum
 enum class ForecastUpdateReasonEnum : uint8_t
 {
     kInternalOptimization = 0x00,
     kLocalOptimization    = 0x01,
     kGridOptimization     = 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 OptOutStateEnum
 enum class OptOutStateEnum : uint8_t
 {
     kNoOptOut    = 0x00,
     kLocalOptOut = 0x01,
     kGridOptOut  = 0x02,
     kOptOut      = 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 PowerAdjustReasonEnum
 enum class PowerAdjustReasonEnum : uint8_t
 {
     kNoAdjustment                = 0x00,
     kLocalOptimizationAdjustment = 0x01,
     kGridOptimizationAdjustment  = 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
 {
     kPowerAdjustment           = 0x1,
     kPowerForecastReporting    = 0x2,
     kStateForecastReporting    = 0x4,
     kStartTimeAdjustment       = 0x8,
     kPausable                  = 0x10,
     kForecastAdjustment        = 0x20,
     kConstraintBasedAdjustment = 0x40,
 };
 } // namespace DeviceEnergyManagement

 namespace EnergyEvse {

 // Enum for EnergyTransferStoppedReasonEnum
 enum class EnergyTransferStoppedReasonEnum : uint8_t
 {
     kEVStopped   = 0x00,
     kEVSEStopped = 0x01,
     kOther       = 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 FaultStateEnum
 enum class FaultStateEnum : uint8_t
 {
     kNoError           = 0x00,
     kMeterFailure      = 0x01,
     kOverVoltage       = 0x02,
     kUnderVoltage      = 0x03,
     kOverCurrent       = 0x04,
     kContactWetFailure = 0x05,
     kContactDryFailure = 0x06,
     kGroundFault       = 0x07,
     kPowerLoss         = 0x08,
     kPowerQuality      = 0x09,
     kPilotShortCircuit = 0x0A,
     kEmergencyStop     = 0x0B,
     kEVDisconnected    = 0x0C,
     kWrongPowerSupply  = 0x0D,
     kLiveNeutralSwap   = 0x0E,
     kOverTemperature   = 0x0F,
     kOther             = 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 = 16,
 };

 // Enum for StateEnum
 enum class StateEnum : uint8_t
 {
     kNotPluggedIn         = 0x00,
     kPluggedInNoDemand    = 0x01,
     kPluggedInDemand      = 0x02,
     kPluggedInCharging    = 0x03,
     kPluggedInDischarging = 0x04,
     kSessionEnding        = 0x05,
     kFault                = 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 SupplyStateEnum
 enum class SupplyStateEnum : uint8_t
 {
     kDisabled            = 0x00,
     kChargingEnabled     = 0x01,
     kDischargingEnabled  = 0x02,
     kDisabledError       = 0x03,
     kDisabledDiagnostics = 0x04,
     kEnabled             = 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
 {
     kChargingPreferences = 0x1,
     kSoCReporting        = 0x2,
     kPlugAndCharge       = 0x4,
     kRfid                = 0x8,
     kV2x                 = 0x10,
 };

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

 namespace EnergyPreference {

 // Enum for EnergyPriorityEnum
 enum class EnergyPriorityEnum : uint8_t
 {
     kComfort          = 0x00,
     kSpeed            = 0x01,
     kEfficiency       = 0x02,
     kWaterConsumption = 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
 {
     kEnergyBalance           = 0x1,
     kLowPowerModeSensitivity = 0x2,
 };
 } // namespace EnergyPreference

 namespace PowerTopology {

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kNodeTopology     = 0x1,
     kTreeTopology     = 0x2,
     kSetTopology      = 0x4,
     kDynamicPowerFlow = 0x8,
 };
 } // namespace PowerTopology

 namespace EnergyEvseMode {

 // Enum for ModeTag
 enum class ModeTag : uint16_t
 {
     kManual        = 0x4000,
     kTimeOfUse     = 0x4001,
     kSolarCharging = 0x4002,
     // kUnknownEnumValue intentionally not defined. This enum never goes
     // through DataModel::Decode, likely because it is a part of a derived
     // cluster. As a result having kUnknownEnumValue in this enum is error
     // prone, and was removed. See
     // src/app/common/templates/config-data.yaml.
 };

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

 namespace WaterHeaterMode {

 // Enum for ModeTag
 enum class ModeTag : uint16_t
 {
     kOff    = 0x4000,
     kManual = 0x4001,
     kTimed  = 0x4002,
     // kUnknownEnumValue intentionally not defined. This enum never goes
     // through DataModel::Decode, likely because it is a part of a derived
     // cluster. As a result having kUnknownEnumValue in this enum is error
     // prone, and was removed. See
     // src/app/common/templates/config-data.yaml.
 };

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

 namespace DeviceEnergyManagementMode {

 // Enum for ModeTag
 enum class ModeTag : uint16_t
 {
     kNoOptimization     = 0x4000,
     kDeviceOptimization = 0x4001,
     kLocalOptimization  = 0x4002,
     kGridOptimization   = 0x4003,
     // kUnknownEnumValue intentionally not defined. This enum never goes
     // through DataModel::Decode, likely because it is a part of a derived
     // cluster. As a result having kUnknownEnumValue in this enum is error
     // prone, and was removed. See
     // src/app/common/templates/config-data.yaml.
 };

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

 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,
     kAliroCredentialIssuerKey     = 0x06,
     kAliroEvictableEndpointKey    = 0x07,
     kAliroNonEvictableEndpointKey = 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 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,
     kAliroCredentialIssuerKey     = 0x0B,
     kAliroEvictableEndpointKey    = 0x0C,
     kAliroNonEvictableEndpointKey = 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,
 };

 // 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,
     kAliro             = 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 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,
     kAliroProvisioning           = 0x2000,
     kAliroBLEUWB                 = 0x4000,
 };
 } // 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 {

 // Bitmap for BarrierControlCapabilities
 enum class BarrierControlCapabilities : uint8_t
 {
     kPartialBarrier = 0x1,
 };

 // Bitmap for BarrierControlSafetyStatus
 enum class BarrierControlSafetyStatus : uint16_t
 {
     kRemoteLockout       = 0x1,
     kTemperDetected      = 0x2,
     kFailedCommunication = 0x4,
     kPositionFailure     = 0x8,
 };
 } // namespace BarrierControl

 namespace ServiceArea {

 // Enum for OperationalStatusEnum
 enum class OperationalStatusEnum : uint8_t
 {
     kPending   = 0x00,
     kOperating = 0x01,
     kSkipped   = 0x02,
     kCompleted = 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 SelectAreasStatus
 enum class SelectAreasStatus : uint8_t
 {
     kSuccess         = 0x00,
     kUnsupportedArea = 0x01,
     kInvalidInMode   = 0x02,
     kInvalidSet      = 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 SkipAreaStatus
 enum class SkipAreaStatus : uint8_t
 {
     kSuccess            = 0x00,
     kInvalidAreaList    = 0x01,
     kInvalidInMode      = 0x02,
     kInvalidSkippedArea = 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
 {
     kSelectWhileRunning = 0x1,
     kProgressReporting  = 0x2,
     kMaps               = 0x4,
 };
 } // namespace ServiceArea

 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 ACCapacityFormatEnum
 enum class ACCapacityFormatEnum : uint8_t
 {
     kBTUh = 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 ACCompressorTypeEnum
 enum class ACCompressorTypeEnum : uint8_t
 {
     kUnknown = 0x00,
     kT1      = 0x01,
     kT2      = 0x02,
     kT3      = 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 ACLouverPositionEnum
 enum class ACLouverPositionEnum : uint8_t
 {
     kClosed        = 0x01,
     kOpen          = 0x02,
     kQuarter       = 0x03,
     kHalf          = 0x04,
     kThreeQuarters = 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 ACRefrigerantTypeEnum
 enum class ACRefrigerantTypeEnum : uint8_t
 {
     kUnknown = 0x00,
     kR22     = 0x01,
     kR410a   = 0x02,
     kR407c   = 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 ACTypeEnum
 enum class ACTypeEnum : uint8_t
 {
     kUnknown          = 0x00,
     kCoolingFixed     = 0x01,
     kHeatPumpFixed    = 0x02,
     kCoolingInverter  = 0x03,
     kHeatPumpInverter = 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 ControlSequenceOfOperationEnum
 enum class ControlSequenceOfOperationEnum : 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 PresetScenarioEnum
 enum class PresetScenarioEnum : uint8_t
 {
     kOccupied     = 0x01,
     kUnoccupied   = 0x02,
     kSleep        = 0x03,
     kWake         = 0x04,
     kVacation     = 0x05,
     kGoingToSleep = 0x06,
     kUserDefined  = 0xFE,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value 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 SetpointChangeSourceEnum
 enum class SetpointChangeSourceEnum : uint8_t
 {
     kManual   = 0x00,
     kSchedule = 0x01,
     kExternal = 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 SetpointRaiseLowerModeEnum
 enum class SetpointRaiseLowerModeEnum : 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 StartOfWeekEnum
 enum class StartOfWeekEnum : uint8_t
 {
     kSunday    = 0x00,
     kMonday    = 0x01,
     kTuesday   = 0x02,
     kWednesday = 0x03,
     kThursday  = 0x04,
     kFriday    = 0x05,
     kSaturday  = 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 SystemModeEnum
 enum class SystemModeEnum : 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,
 };

 // Enum for TemperatureSetpointHoldEnum
 enum class TemperatureSetpointHoldEnum : uint8_t
 {
     kSetpointHoldOff = 0x00,
     kSetpointHoldOn  = 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 ThermostatRunningModeEnum
 enum class ThermostatRunningModeEnum : 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,
 };

 // Bitmap for ACErrorCodeBitmap
 enum class ACErrorCodeBitmap : uint32_t
 {
     kCompressorFail    = 0x1,
     kRoomSensorFail    = 0x2,
     kOutdoorSensorFail = 0x4,
     kCoilSensorFail    = 0x8,
     kFanFail           = 0x10,
 };

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

 // Bitmap for HVACSystemTypeBitmap
 enum class HVACSystemTypeBitmap : uint8_t
 {
     kCoolingStage      = 0x3,
     kHeatingStage      = 0xC,
     kHeatingIsHeatPump = 0x10,
     kHeatingUsesFuel   = 0x20,
 };

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

 // Bitmap for PresetTypeFeaturesBitmap
 enum class PresetTypeFeaturesBitmap : uint16_t
 {
     kAutomatic     = 0x1,
     kSupportsNames = 0x2,
 };

 // Bitmap for ProgrammingOperationModeBitmap
 enum class ProgrammingOperationModeBitmap : uint8_t
 {
     kScheduleActive = 0x1,
     kAutoRecovery   = 0x2,
     kEconomy        = 0x4,
 };

 // Bitmap for RelayStateBitmap
 enum class RelayStateBitmap : uint16_t
 {
     kHeat       = 0x1,
     kCool       = 0x2,
     kFan        = 0x4,
     kHeatStage2 = 0x8,
     kCoolStage2 = 0x10,
     kFanStage2  = 0x20,
     kFanStage3  = 0x40,
 };

 // Bitmap for RemoteSensingBitmap
 enum class RemoteSensingBitmap : uint8_t
 {
     kLocalTemperature   = 0x1,
     kOutdoorTemperature = 0x2,
     kOccupancy          = 0x4,
 };

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

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

 // Bitmap for ScheduleTypeFeaturesBitmap
 enum class ScheduleTypeFeaturesBitmap : uint16_t
 {
     kSupportsPresets   = 0x1,
     kSupportsSetpoints = 0x2,
     kSupportsNames     = 0x4,
     kSupportsOff       = 0x8,
 };
 } // 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,
     kOffHighAuto       = 0x04,
     kOffHigh           = 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 {

 // Enum for KeypadLockoutEnum
 enum class KeypadLockoutEnum : uint8_t
 {
     kNoLockout = 0x00,
     kLockout1  = 0x01,
     kLockout2  = 0x02,
     kLockout3  = 0x03,
     kLockout4  = 0x04,
     kLockout5  = 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 ScheduleProgrammingVisibilityEnum
 enum class ScheduleProgrammingVisibilityEnum : uint8_t
 {
     kScheduleProgrammingPermitted = 0x00,
     kScheduleProgrammingDenied    = 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 TemperatureDisplayModeEnum
 enum class TemperatureDisplayModeEnum : uint8_t
 {
     kCelsius    = 0x00,
     kFahrenheit = 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 ThermostatUserInterfaceConfiguration

 namespace ColorControl {

 // Enum for ColorLoopActionEnum
 enum class ColorLoopActionEnum : 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 ColorLoopDirectionEnum
 enum class ColorLoopDirectionEnum : uint8_t
 {
     kDecrement = 0x00,
     kIncrement = 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 ColorModeEnum
 enum class ColorModeEnum : uint8_t
 {
     kCurrentHueAndCurrentSaturation = 0x00,
     kCurrentXAndCurrentY            = 0x01,
     kColorTemperatureMireds         = 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 DirectionEnum
 enum class DirectionEnum : uint8_t
 {
     kShortest = 0x00,
     kLongest  = 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 DriftCompensationEnum
 enum class DriftCompensationEnum : uint8_t
 {
     kNone                                  = 0x00,
     kOtherOrUnknown                        = 0x01,
     kTemperatureMonitoring                 = 0x02,
     kOpticalLuminanceMonitoringAndFeedback = 0x03,
     kOpticalColorMonitoringAndFeedback     = 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 EnhancedColorModeEnum
 enum class EnhancedColorModeEnum : uint8_t
 {
     kCurrentHueAndCurrentSaturation         = 0x00,
     kCurrentXAndCurrentY                    = 0x01,
     kColorTemperatureMireds                 = 0x02,
     kEnhancedCurrentHueAndCurrentSaturation = 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 MoveModeEnum
 enum class MoveModeEnum : 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 StepModeEnum
 enum class StepModeEnum : 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 ColorCapabilitiesBitmap
 enum class ColorCapabilitiesBitmap : uint16_t
 {
     kHueSaturation    = 0x1,
     kEnhancedHue      = 0x2,
     kColorLoop        = 0x4,
     kXy               = 0x8,
     kColorTemperature = 0x10,
 };

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

 // Bitmap for OptionsBitmap
 enum class OptionsBitmap : uint8_t
 {
     kExecuteIfOff = 0x1,
 };

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

 namespace BallastConfiguration {

 // Bitmap for BallastStatusBitmap
 enum class BallastStatusBitmap : uint8_t
 {
     kBallastNonOperational = 0x1,
     kLampFailure           = 0x2,
 };

 // Bitmap for LampAlarmModeBitmap
 enum class LampAlarmModeBitmap : uint8_t
 {
     kLampBurnHours = 0x1,
 };
 } // 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 Feature
 enum class Feature : uint32_t
 {
     kOther           = 0x1,
     kPassiveInfrared = 0x2,
     kUltrasonic      = 0x4,
     kPhysicalContact = 0x8,
     kActiveInfrared  = 0x10,
     kRadar           = 0x20,
     kRFSensing       = 0x40,
     kVision          = 0x80,
 };

 // 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 {

 using LevelValueEnum = Clusters::detail::LevelValueEnum;

 using MeasurementMediumEnum = Clusters::detail::MeasurementMediumEnum;

 using MeasurementUnitEnum = Clusters::detail::MeasurementUnitEnum;

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

 namespace CarbonDioxideConcentrationMeasurement {

 using LevelValueEnum = Clusters::detail::LevelValueEnum;

 using MeasurementMediumEnum = Clusters::detail::MeasurementMediumEnum;

 using MeasurementUnitEnum = Clusters::detail::MeasurementUnitEnum;

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

 namespace NitrogenDioxideConcentrationMeasurement {

 using LevelValueEnum = Clusters::detail::LevelValueEnum;

 using MeasurementMediumEnum = Clusters::detail::MeasurementMediumEnum;

 using MeasurementUnitEnum = Clusters::detail::MeasurementUnitEnum;

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

 namespace OzoneConcentrationMeasurement {

 using LevelValueEnum = Clusters::detail::LevelValueEnum;

 using MeasurementMediumEnum = Clusters::detail::MeasurementMediumEnum;

 using MeasurementUnitEnum = Clusters::detail::MeasurementUnitEnum;

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

 namespace Pm25ConcentrationMeasurement {

 using LevelValueEnum = Clusters::detail::LevelValueEnum;

 using MeasurementMediumEnum = Clusters::detail::MeasurementMediumEnum;

 using MeasurementUnitEnum = Clusters::detail::MeasurementUnitEnum;

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

 namespace FormaldehydeConcentrationMeasurement {

 using LevelValueEnum = Clusters::detail::LevelValueEnum;

 using MeasurementMediumEnum = Clusters::detail::MeasurementMediumEnum;

 using MeasurementUnitEnum = Clusters::detail::MeasurementUnitEnum;

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

 namespace Pm1ConcentrationMeasurement {

 using LevelValueEnum = Clusters::detail::LevelValueEnum;

 using MeasurementMediumEnum = Clusters::detail::MeasurementMediumEnum;

 using MeasurementUnitEnum = Clusters::detail::MeasurementUnitEnum;

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

 namespace Pm10ConcentrationMeasurement {

 using LevelValueEnum = Clusters::detail::LevelValueEnum;

 using MeasurementMediumEnum = Clusters::detail::MeasurementMediumEnum;

 using MeasurementUnitEnum = Clusters::detail::MeasurementUnitEnum;

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

 namespace TotalVolatileOrganicCompoundsConcentrationMeasurement {

 using LevelValueEnum = Clusters::detail::LevelValueEnum;

 using MeasurementMediumEnum = Clusters::detail::MeasurementMediumEnum;

 using MeasurementUnitEnum = Clusters::detail::MeasurementUnitEnum;

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

 namespace RadonConcentrationMeasurement {

 using LevelValueEnum = Clusters::detail::LevelValueEnum;

 using MeasurementMediumEnum = Clusters::detail::MeasurementMediumEnum;

 using MeasurementUnitEnum = Clusters::detail::MeasurementUnitEnum;

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

 namespace WiFiNetworkManagement {} // namespace WiFiNetworkManagement

 namespace ThreadBorderRouterManagement {

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

 namespace ThreadNetworkDirectory {} // namespace ThreadNetworkDirectory

 namespace WakeOnLan {} // namespace WakeOnLan

 namespace Channel {

 // Enum for ChannelTypeEnum
 enum class ChannelTypeEnum : uint8_t
 {
     kSatellite   = 0x00,
     kCable       = 0x01,
     kTerrestrial = 0x02,
     kOtt         = 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 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,
 };

 // Enum for StatusEnum
 enum class StatusEnum : 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,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kChannelList     = 0x1,
     kLineupInfo      = 0x2,
     kElectronicGuide = 0x4,
     kRecordProgram   = 0x8,
 };

 // Bitmap for RecordingFlagBitmap
 enum class RecordingFlagBitmap : uint32_t
 {
     kScheduled    = 0x1,
     kRecordSeries = 0x2,
     kRecorded     = 0x4,
 };
 } // namespace Channel

 namespace TargetNavigator {

 // Enum for StatusEnum
 enum class StatusEnum : 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 CharacteristicEnum
 enum class CharacteristicEnum : uint8_t
 {
     kForcedSubtitles              = 0x00,
     kDescribesVideo               = 0x01,
     kEasyToRead                   = 0x02,
     kFrameBased                   = 0x03,
     kMainProgram                  = 0x04,
     kOriginalContent              = 0x05,
     kVoiceOverTranslation         = 0x06,
     kCaption                      = 0x07,
     kSubtitle                     = 0x08,
     kAlternate                    = 0x09,
     kSupplementary                = 0x0A,
     kCommentary                   = 0x0B,
     kDubbedTranslation            = 0x0C,
     kDescription                  = 0x0D,
     kMetadata                     = 0x0E,
     kEnhancedAudioIntelligibility = 0x0F,
     kEmergency                    = 0x10,
     kKaraoke                      = 0x11,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 18,
 };

 // 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,
 };

 // Enum for StatusEnum
 enum class StatusEnum : 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,
 };

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kAdvancedSeek  = 0x1,
     kVariableSpeed = 0x2,
     kTextTracks    = 0x4,
     kAudioTracks   = 0x8,
     kAudioAdvance  = 0x10,
 };
 } // 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 CECKeyCodeEnum
 enum class CECKeyCodeEnum : 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 StatusEnum
 enum class StatusEnum : 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 CharacteristicEnum
 enum class CharacteristicEnum : uint8_t
 {
     kForcedSubtitles              = 0x00,
     kDescribesVideo               = 0x01,
     kEasyToRead                   = 0x02,
     kFrameBased                   = 0x03,
     kMainProgram                  = 0x04,
     kOriginalContent              = 0x05,
     kVoiceOverTranslation         = 0x06,
     kCaption                      = 0x07,
     kSubtitle                     = 0x08,
     kAlternate                    = 0x09,
     kSupplementary                = 0x0A,
     kCommentary                   = 0x0B,
     kDubbedTranslation            = 0x0C,
     kDescription                  = 0x0D,
     kMetadata                     = 0x0E,
     kEnhancedAudioIntelligibility = 0x0F,
     kEmergency                    = 0x10,
     kKaraoke                      = 0x11,
     // All received enum values that are not listed above will be mapped
     // to kUnknownEnumValue. This is a helper enum value that should only
     // be used by code to process how it handles receiving and unknown
     // enum value. This specific should never be transmitted.
     kUnknownEnumValue = 18,
 };

 // 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,
     kSeason     = 0x0E,
     kEpisode    = 0x0F,
     kAny        = 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 StatusEnum
 enum class StatusEnum : uint8_t
 {
     kSuccess                = 0x00,
     kURLNotAvailable        = 0x01,
     kAuthFailed             = 0x02,
     kTextTrackNotAvailable  = 0x03,
     kAudioTrackNotAvailable = 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
 {
     kContentSearch = 0x1,
     kURLPlayback   = 0x2,
     kAdvancedSeek  = 0x3,
     kTextTracks    = 0x4,
     kAudioTracks   = 0x5,
 };

 // Bitmap for SupportedProtocolsBitmap
 enum class SupportedProtocolsBitmap : 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 StatusEnum
 enum class StatusEnum : uint8_t
 {
     kSuccess             = 0x00,
     kAppNotAvailable     = 0x01,
     kSystemBusy          = 0x02,
     kPendingUserApproval = 0x03,
     kDownloading         = 0x04,
     kInstalling          = 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
 {
     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 ContentControl {

 // Bitmap for Feature
 enum class Feature : uint32_t
 {
     kScreenTime             = 0x1,
     kPINManagement          = 0x2,
     kBlockUnrated           = 0x4,
     kOnDemandContentRating  = 0x8,
     kScheduledContentRating = 0x10,
 };
 } // namespace ContentControl

 namespace ContentAppObserver {

 // Enum for StatusEnum
 enum class StatusEnum : uint8_t
 {
     kSuccess        = 0x00,
     kUnexpectedData = 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 ContentAppObserver

 namespace EcosystemInformation {} // namespace EcosystemInformation

 namespace CommissionerControl {

 // Bitmap for SupportedDeviceCategoryBitmap
 enum class SupportedDeviceCategoryBitmap : uint32_t
 {
     kFabricSynchronization = 0x1,
 };
 } // namespace CommissionerControl

 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 SampleMei {} // namespace SampleMei

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

 // Included at the end, so all our definitions above are available.
 #include <app/common/CompatEnumNames.h>