zzz_generated/app-common/app-common/zap-generated/cluster-enums.h

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

namespace Actions {

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

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

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

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

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

namespace BasicInformation {

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

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

namespace OtaSoftwareUpdateProvider {

// Enum for 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,
    // All received enum values that are not listed above will be mapped
    // to kUnknownEnumValue. This is a helper enum value that should only
    // be used by code to process how it handles receiving and unknown
    // enum value. This specific should never be transmitted.
    kUnknownEnumValue = 5,
};

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

namespace NetworkCommissioning {

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

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

// Bitmap for Feature
enum class Feature : uint32_t
{
    kWiFiNetworkInterface     = 0x1,
    kThreadNetworkInterface   = 0x2,
    kEthernetNetworkInterface = 0x4,
    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,
};
} // 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,
};
} // namespace BridgedDeviceBasicInformation

namespace Switch {

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

namespace AdministratorCommissioning {

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

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

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

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

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

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

namespace TemperatureControl {

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

namespace RefrigeratorAlarm {

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

namespace DishwasherMode {

// Enum for ModeTag
enum class ModeTag : uint16_t
{
    kNormal = 0x4000,
    kHeavy  = 0x4001,
    kLight  = 0x4002,
    // 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 AlarmMap
enum class AlarmMap : 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 {} // namespace MicrowaveOvenControl

namespace OperationalState {

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

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

namespace RvcOperationalState {

// Enum for ErrorStateEnum
enum class ErrorStateEnum : uint8_t
{
    kFailedToFindChargingDock = 0x40,
    kStuck                    = 0x41,
    kDustBinMissing           = 0x42,
    kDustBinFull              = 0x43,
    kWaterTankEmpty           = 0x44,
    kWaterTankMissing         = 0x45,
    kWaterTankLidOpen         = 0x46,
    kMopCleaningPadMissing    = 0x47,
    // 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,
    kExplicit     = 0x2,
    kTableSize    = 0x4,
    kFabricScenes = 0x8,
};

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

namespace HepaFilterMonitoring {

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

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

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

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

namespace ActivatedCarbonFilterMonitoring {

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

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

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

// Bitmap for Feature
enum class Feature : uint32_t
{
    kCondition              = 0x1,
    kWarning                = 0x2,
    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 ElectricalEnergyMeasurement {

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

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

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

// Enum for CauseEnum
enum class CauseEnum : uint8_t
{
    kNormalCompletion = 0x00,
    kOffline          = 0x01,
    kFault            = 0x02,
    kUserOptOut       = 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 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,
    kUserOptOut        = 0x03,
    kPowerAdjustActive = 0x04,
    kPaused            = 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 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,
};

// Bitmap for Feature
enum class Feature : uint32_t
{
    kPowerAdjustment        = 0x1,
    kPowerForecastReporting = 0x2,
    kStateForecastReporting = 0x4,
    kForecastAdjustment     = 0x8,
};
} // 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,
    // All received enum values that are not listed above will be mapped
    // to kUnknownEnumValue. This is a helper enum value 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
{
    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 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 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
{
    kUnspecified = 0x00,
    kOccupied    = 0x01,
    kUnoccupied  = 0x02,
    kSleep       = 0x03,
    kWake        = 0x04,
    kVacation    = 0x05,
    kUserDefined = 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 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,
    kSetpoints                   = 0x200,
    kQueuedPresetsSupported      = 0x400,
};

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

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

// Bitmap for TemperatureSetpointHoldPolicyBitmap
enum class TemperatureSetpointHoldPolicyBitmap : uint8_t
{
    kHoldDurationElapsed                = 0x1,
    kHoldDurationElapsedOrPresetChanged = 0x2,
};
} // namespace Thermostat

namespace FanControl {

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

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

// Enum for FanModeSequenceEnum
enum class FanModeSequenceEnum : uint8_t
{
    kOffLowMedHigh     = 0x00,
    kOffLowHigh        = 0x01,
    kOffLowMedHighAuto = 0x02,
    kOffLowHighAuto    = 0x03,
    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 ColorLoopAction
enum class ColorLoopAction : uint8_t
{
    kDeactivate                            = 0x00,
    kActivateFromColorLoopStartEnhancedHue = 0x01,
    kActivateFromEnhancedCurrentHue        = 0x02,
    // All received enum values that are not listed above will be mapped
    // to kUnknownEnumValue. This is a helper enum value that should only
    // be used by code to process how it handles receiving and unknown
    // enum value. This specific should never be transmitted.
    kUnknownEnumValue = 3,
};

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

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

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

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

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

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

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

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

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

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

namespace BallastConfiguration {

// 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 OccupancyBitmap
enum class OccupancyBitmap : uint8_t
{
    kOccupied = 0x1,
};

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

namespace CarbonMonoxideConcentrationMeasurement {

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

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

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

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

namespace CarbonDioxideConcentrationMeasurement {

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

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

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

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

namespace NitrogenDioxideConcentrationMeasurement {

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

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

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

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

namespace OzoneConcentrationMeasurement {

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

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

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

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

namespace Pm25ConcentrationMeasurement {

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

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

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

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

namespace FormaldehydeConcentrationMeasurement {

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

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

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

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

namespace Pm1ConcentrationMeasurement {

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

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

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

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

namespace Pm10ConcentrationMeasurement {

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

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

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

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

namespace TotalVolatileOrganicCompoundsConcentrationMeasurement {

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

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

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

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

namespace RadonConcentrationMeasurement {

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

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

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

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

namespace WakeOnLan {} // namespace WakeOnLan

namespace Channel {

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

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

// 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 = 0x3,
    kRecordProgram   = 0x4,
};

// Bitmap for RecordingFlagBitmap
enum class RecordingFlagBitmap : uint32_t
{
    kScheduled    = 0x1,
    kRecordSeries = 0x2,
    kRecorded     = 0x3,
};
} // 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    = 0x3,
    kAudioTracks   = 0x4,
    kAudioAdvance  = 0x5,
};
} // 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,
    kWebRTC = 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,
    // All received enum values that are not listed above will be mapped
    // to kUnknownEnumValue. This is a helper enum value that should only
    // be used by code to process how it handles receiving and unknown
    // enum value. This specific should never be transmitted.
    kUnknownEnumValue = 3,
};

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

namespace ApplicationBasic {

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

namespace AccountLogin {} // namespace AccountLogin

namespace ContentControl {

// Bitmap for Feature
enum class Feature : uint32_t
{
    kScreenTime             = 0x1,
    kPINManagement          = 0x2,
    kBlockUnrated           = 0x3,
    kOnDemandContentRating  = 0x4,
    kScheduledContentRating = 0x5,
};
} // 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 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/CompatEnumNames.h>