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>

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

namespace chip {
namespace app {
namespace Clusters {

namespace Identify {

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

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

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

namespace Groups {

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

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

namespace Scenes {

// Bitmap for Feature
enum class Feature : uint32_t
{
    kSceneNames   = 0x1,
    kExplicit     = 0x2,
    kTableSize    = 0x4,
    kFabricScenes = 0x8,
};

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

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

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

namespace OnOffSwitchConfiguration {} // namespace OnOffSwitchConfiguration

namespace LevelControl {

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

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

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

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

namespace BinaryInputBasic {} // namespace BinaryInputBasic

namespace PulseWidthModulation {} // namespace PulseWidthModulation

namespace Descriptor {

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

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

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

namespace OtaSoftwareUpdateRequestor {

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

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

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

namespace LocalizationConfiguration {} // namespace LocalizationConfiguration

namespace TimeFormatLocalization {

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

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

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

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

namespace DiagnosticLogs {

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

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

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

namespace GeneralDiagnostics {

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

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

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

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

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

namespace SoftwareDiagnostics {

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

namespace ThreadNetworkDiagnostics {

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

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

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

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

namespace WiFiNetworkDiagnostics {

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

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

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

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

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

namespace EthernetNetworkDiagnostics {

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

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

namespace TimeSynchronization {

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

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

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

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

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

namespace BridgedDeviceBasicInformation {

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

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

namespace Switch {

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

namespace AdministratorCommissioning {

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

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

namespace OperationalCredentials {

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

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

namespace GroupKeyManagement {

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

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

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

namespace ModeSelect {

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

namespace LaundryWasherMode {

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

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

namespace RefrigeratorAndTemperatureControlledCabinetMode {

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

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

namespace LaundryWasherControls {

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

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

namespace RvcRunMode {

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

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

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

namespace RvcCleanMode {

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

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

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

namespace TemperatureControl {

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

namespace RefrigeratorAlarm {

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

namespace DishwasherMode {

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

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

namespace AirQuality {

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

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

namespace SmokeCoAlarm {

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

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

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

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

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

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

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

namespace DishwasherAlarm {

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

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

namespace OperationalState {

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

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

namespace RvcOperationalState {

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

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

namespace HepaFilterMonitoring {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

namespace WindowCovering {

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

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

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

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

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

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

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

namespace BarrierControl {

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

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

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

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

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

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

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

namespace FanControl {

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

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

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

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

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

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

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

namespace ThermostatUserInterfaceConfiguration {} // namespace ThermostatUserInterfaceConfiguration

namespace ColorControl {

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

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

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

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

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

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

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

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

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

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

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

namespace BallastConfiguration {} // namespace BallastConfiguration

namespace IlluminanceMeasurement {

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

namespace TemperatureMeasurement {} // namespace TemperatureMeasurement

namespace PressureMeasurement {

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

namespace FlowMeasurement {} // namespace FlowMeasurement

namespace RelativeHumidityMeasurement {} // namespace RelativeHumidityMeasurement

namespace OccupancySensing {

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

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

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

namespace CarbonMonoxideConcentrationMeasurement {

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

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

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

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

namespace CarbonDioxideConcentrationMeasurement {

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

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

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

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

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

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

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

namespace TargetNavigator {

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

namespace MediaPlayback {

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

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

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

namespace MediaInput {

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

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

namespace LowPower {} // namespace LowPower

namespace KeypadInput {

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

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

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

namespace ContentLauncher {

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

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

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

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

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

namespace AudioOutput {

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

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

namespace ApplicationLauncher {

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

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

namespace ApplicationBasic {

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

namespace AccountLogin {} // namespace AccountLogin

namespace ElectricalMeasurement {} // namespace ElectricalMeasurement

namespace UnitTesting {

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

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

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

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

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

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

namespace FaultInjection {

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

namespace SampleMei {} // namespace SampleMei

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