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

// THIS FILE IS GENERATED BY ZAP

#pragma once

#include <stdint.h>


namespace chip {
namespace app {
namespace Clusters {

namespace detail {
// Enums shared across multiple clusters.





































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

























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


















































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








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


// Enum for MeasurementTypeEnum
enum class MeasurementTypeEnum : uint16_t {
kUnspecified = 0x00,
kVoltage = 0x01,
kActiveCurrent = 0x02,
kReactiveCurrent = 0x03,
kApparentCurrent = 0x04,
kActivePower = 0x05,
kReactivePower = 0x06,
kApparentPower = 0x07,
kRMSVoltage = 0x08,
kRMSCurrent = 0x09,
kRMSPower = 0x0A,
kFrequency = 0x0B,
kPowerFactor = 0x0C,
kNeutralCurrent = 0x0D,
kElectricalEnergy = 0x0E,
// All received enum values that are not listed above will be mapped
// to kUnknownEnumValue. This is a helper enum value that should only
// be used by code to process how it handles receiving and unknown
// enum value. This specific should never be transmitted.
kUnknownEnumValue = 15,
};


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












































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


































// Enum for StreamTypeEnum
enum class StreamTypeEnum : uint8_t {
kInternal = 0x00,
kRecording = 0x01,
kAnalysis = 0x02,
kLiveView = 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 WebRTCEndReasonEnum
enum class WebRTCEndReasonEnum : uint8_t {
kIceFailed = 0x00,
kIceTimeout = 0x01,
kUserHangup = 0x02,
kUserBusy = 0x03,
kReplaced = 0x04,
kNoUserMedia = 0x05,
kInviteTimeout = 0x06,
kAnsweredElsewhere = 0x07,
kOutOfResources = 0x08,
kMediaTimeout = 0x09,
kLowPower = 0x0A,
kUnknownReason = 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,
};





// Bitmaps shared across multiple clusters.




















































































































































// Bitmap for WebRTCMetadataOptions
enum class WebRTCMetadataOptions : uint8_t {
kDataTLV = 0x1,
};








} // namespace detail

namespace Globals {
// Global enums.





















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



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










































































// Enum for FloorSurfaceTag
enum class FloorSurfaceTag : uint8_t {
kCarpet = 0x00,
kCeramic = 0x01,
kConcrete = 0x02,
kCork = 0x03,
kDeepCarpet = 0x04,
kDirt = 0x05,
kEngineeredWood = 0x06,
kGlass = 0x07,
kGrass = 0x08,
kHardwood = 0x09,
kLaminate = 0x0A,
kLinoleum = 0x0B,
kMat = 0x0C,
kMetal = 0x0D,
kPlastic = 0x0E,
kPolishedConcrete = 0x0F,
kRubber = 0x10,
kRug = 0x11,
kSand = 0x12,
kStone = 0x13,
kTatami = 0x14,
kTerrazzo = 0x15,
kTile = 0x16,
kVinyl = 0x17,
// All received enum values that are not listed above will be mapped
// to kUnknownEnumValue. This is a helper enum value that should only
// be used by code to process how it handles receiving and unknown
// enum value. This specific should never be transmitted.
kUnknownEnumValue = 24,
};














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















































// Enum for PositionTag
enum class PositionTag : uint8_t {
kLeft = 0x00,
kRight = 0x01,
kTop = 0x02,
kBottom = 0x03,
kMiddle = 0x04,
kRow = 0x05,
kColumn = 0x06,
// All received enum values that are not listed above will be mapped
// to kUnknownEnumValue. This is a helper enum value that should only
// be used by code to process how it handles receiving and unknown
// enum value. This specific should never be transmitted.
kUnknownEnumValue = 7,
};











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





































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



// Enum for ThreeLevelAutoEnum
enum class ThreeLevelAutoEnum : uint8_t {
kLow = 0x00,
kMedium = 0x01,
kHigh = 0x02,
kAutomatic = 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,
};















// Global bitmaps.














































































































































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














} // namespace Globals

namespace Identify {

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

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

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

namespace Groups {

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

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

namespace OnOff {

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

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

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

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

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

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

namespace LevelControl {

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

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

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

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

namespace PulseWidthModulation {
} // namespace PulseWidthModulation

namespace Descriptor {

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

namespace Binding {
} // namespace Binding

namespace AccessControl {

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

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

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

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

// Bitmap for Feature
enum class Feature : uint32_t {
kExtension = 0x1,
kManagedDevice = 0x2,
};
} // namespace AccessControl

namespace Actions {

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

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

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

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

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

namespace BasicInformation {

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

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

namespace OtaSoftwareUpdateProvider {

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

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

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

namespace OtaSoftwareUpdateRequestor {

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

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

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

namespace LocalizationConfiguration {
} // namespace LocalizationConfiguration

namespace TimeFormatLocalization {

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

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

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

namespace UnitLocalization {

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

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

namespace PowerSourceConfiguration {
} // namespace PowerSourceConfiguration

namespace PowerSource {

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

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

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

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

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

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

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

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

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

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

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

namespace GeneralCommissioning {

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

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

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

namespace NetworkCommissioning {

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

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

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

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

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

namespace DiagnosticLogs {

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

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

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

namespace GeneralDiagnostics {

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

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

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

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

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

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

namespace SoftwareDiagnostics {

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

namespace ThreadNetworkDiagnostics {

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

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

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

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

namespace WiFiNetworkDiagnostics {

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

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

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

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

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

namespace EthernetNetworkDiagnostics {

// Enum for PHYRateEnum
enum class PHYRateEnum : uint8_t {
kRate10M = 0x00,
kRate100M = 0x01,
kRate1G = 0x02,
kRate25g = 0x03,
kRate5G = 0x04,
kRate10G = 0x05,
kRate40G = 0x06,
kRate100G = 0x07,
kRate200G = 0x08,
kRate400G = 0x09,
// All received enum values that are not listed above will be mapped
// to kUnknownEnumValue. This is a helper enum value that should only
// be used by code to process how it handles receiving and unknown
// enum value. This specific should never be transmitted.
kUnknownEnumValue = 10,
};

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

namespace TimeSynchronization {

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

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

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

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

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

namespace BridgedDeviceBasicInformation {

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

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

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

namespace Switch {

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

namespace AdministratorCommissioning {

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

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

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

namespace OperationalCredentials {

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

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

namespace GroupKeyManagement {

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

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

namespace FixedLabel {
} // namespace FixedLabel

namespace UserLabel {
} // namespace UserLabel

namespace ProxyConfiguration {
} // namespace ProxyConfiguration

namespace ProxyDiscovery {
} // namespace ProxyDiscovery

namespace ProxyValid {
} // namespace ProxyValid

namespace BooleanState {
} // namespace BooleanState

namespace IcdManagement {

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

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

// Bitmap for Feature
enum class Feature : uint32_t {
kCheckInProtocolSupport = 0x1,
kUserActiveModeTrigger = 0x2,
kLongIdleTimeSupport = 0x4,
kDynamicSitLitSupport = 0x8,
};

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

namespace Timer {

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

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

namespace OvenCavityOperationalState {

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

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

namespace OvenMode {

// Enum for ModeTag
enum class ModeTag : uint16_t {
kAuto = 0x00,
kQuick = 0x01,
kQuiet = 0x02,
kLowNoise = 0x03,
kLowEnergy = 0x04,
kVacation = 0x05,
kMin = 0x06,
kMax = 0x07,
kNight = 0x08,
kDay = 0x09,
kBake = 0x4000,
kConvection = 0x4001,
kGrill = 0x4002,
kRoast = 0x4003,
kClean = 0x4004,
kConvectionBake = 0x4005,
kConvectionRoast = 0x4006,
kWarming = 0x4007,
kProofing = 0x4008,
// All received enum values that are not listed above will be mapped
// to kUnknownEnumValue. This is a helper enum value that should only
// be used by code to process how it handles receiving and unknown
// enum value. This specific should never be transmitted.
kUnknownEnumValue = 10,
};

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

namespace LaundryDryerControls {

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

namespace ModeSelect {

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

namespace LaundryWasherMode {

// Enum for ModeTag
enum class ModeTag : uint16_t {
kAuto = 0x00,
kQuick = 0x01,
kQuiet = 0x02,
kLowNoise = 0x03,
kLowEnergy = 0x04,
kVacation = 0x05,
kMin = 0x06,
kMax = 0x07,
kNight = 0x08,
kDay = 0x09,
kNormal = 0x4000,
kDelicate = 0x4001,
kHeavy = 0x4002,
kWhites = 0x4003,
// kUnknownEnumValue intentionally not defined. This enum never goes
// through DataModel::Decode, likely because it is a part of a derived
// cluster. As a result having kUnknownEnumValue in this enum is error
// prone, and was removed. See
// src/app/common/templates/config-data.yaml.
};

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

namespace RefrigeratorAndTemperatureControlledCabinetMode {

// Enum for ModeTag
enum class ModeTag : uint16_t {
kAuto = 0x00,
kQuick = 0x01,
kQuiet = 0x02,
kLowNoise = 0x03,
kLowEnergy = 0x04,
kVacation = 0x05,
kMin = 0x06,
kMax = 0x07,
kNight = 0x08,
kDay = 0x09,
kRapidCool = 0x4000,
kRapidFreeze = 0x4001,
// kUnknownEnumValue intentionally not defined. This enum never goes
// through DataModel::Decode, likely because it is a part of a derived
// cluster. As a result having kUnknownEnumValue in this enum is error
// prone, and was removed. See
// src/app/common/templates/config-data.yaml.
};

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

namespace LaundryWasherControls {

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

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

namespace RvcRunMode {

// Enum for ModeTag
enum class ModeTag : uint16_t {
kAuto = 0x00,
kQuick = 0x01,
kQuiet = 0x02,
kLowNoise = 0x03,
kLowEnergy = 0x04,
kVacation = 0x05,
kMin = 0x06,
kMax = 0x07,
kNight = 0x08,
kDay = 0x09,
kIdle = 0x4000,
kCleaning = 0x4001,
kMapping = 0x4002,
// kUnknownEnumValue intentionally not defined. This enum never goes
// through DataModel::Decode, likely because it is a part of a derived
// cluster. As a result having kUnknownEnumValue in this enum is error
// prone, and was removed. See
// src/app/common/templates/config-data.yaml.
};

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

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

namespace RvcCleanMode {

// Enum for ModeTag
enum class ModeTag : uint16_t {
kAuto = 0x00,
kQuick = 0x01,
kQuiet = 0x02,
kLowNoise = 0x03,
kLowEnergy = 0x04,
kVacation = 0x05,
kMin = 0x06,
kMax = 0x07,
kNight = 0x08,
kDay = 0x09,
kDeepClean = 0x4000,
kVacuum = 0x4001,
kMop = 0x4002,
// kUnknownEnumValue intentionally not defined. This enum never goes
// through DataModel::Decode, likely because it is a part of a derived
// cluster. As a result having kUnknownEnumValue in this enum is error
// prone, and was removed. See
// src/app/common/templates/config-data.yaml.
};

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

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

namespace TemperatureControl {

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

namespace RefrigeratorAlarm {

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

namespace DishwasherMode {

// Enum for ModeTag
enum class ModeTag : uint16_t {
kAuto = 0x00,
kQuick = 0x01,
kQuiet = 0x02,
kLowNoise = 0x03,
kLowEnergy = 0x04,
kVacation = 0x05,
kMin = 0x06,
kMax = 0x07,
kNight = 0x08,
kDay = 0x09,
kNormal = 0x4000,
kHeavy = 0x4001,
kLight = 0x4002,
// kUnknownEnumValue intentionally not defined. This enum never goes
// through DataModel::Decode, likely because it is a part of a derived
// cluster. As a result having kUnknownEnumValue in this enum is error
// prone, and was removed. See
// src/app/common/templates/config-data.yaml.
};

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

namespace AirQuality {

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

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

namespace SmokeCoAlarm {

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

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

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

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

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

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

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

namespace DishwasherAlarm {

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

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

namespace MicrowaveOvenMode {

// Enum for ModeTag
enum class ModeTag : uint16_t {
kAuto = 0x00,
kQuick = 0x01,
kQuiet = 0x02,
kLowNoise = 0x03,
kLowEnergy = 0x04,
kVacation = 0x05,
kMin = 0x06,
kMax = 0x07,
kNight = 0x08,
kDay = 0x09,
kNormal = 0x4000,
kDefrost = 0x4001,
// All received enum values that are not listed above will be mapped
// to kUnknownEnumValue. This is a helper enum value that should only
// be used by code to process how it handles receiving and unknown
// enum value. This specific should never be transmitted.
kUnknownEnumValue = 10,
};

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

namespace MicrowaveOvenControl {

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

namespace OperationalState {

// 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 {
kNoError = 0x00,
kUnableToStartOrResume = 0x01,
kUnableToCompleteOperation = 0x02,
kCommandInvalidInState = 0x03,
kFailedToFindChargingDock = 0x40,
kStuck = 0x41,
kDustBinMissing = 0x42,
kDustBinFull = 0x43,
kWaterTankEmpty = 0x44,
kWaterTankMissing = 0x45,
kWaterTankLidOpen = 0x46,
kMopCleaningPadMissing = 0x47,
// kUnknownEnumValue intentionally not defined. This enum never goes
// through DataModel::Decode, likely because it is a part of a derived
// cluster. As a result having kUnknownEnumValue in this enum is error
// prone, and was removed. See
// src/app/common/templates/config-data.yaml.
};

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

namespace ScenesManagement {

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

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

namespace HepaFilterMonitoring {

using ChangeIndicationEnum = Clusters::detail::ChangeIndicationEnum;

using DegradationDirectionEnum = Clusters::detail::DegradationDirectionEnum;

using ProductIdentifierTypeEnum = Clusters::detail::ProductIdentifierTypeEnum;

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

namespace ActivatedCarbonFilterMonitoring {

using ChangeIndicationEnum = Clusters::detail::ChangeIndicationEnum;

using DegradationDirectionEnum = Clusters::detail::DegradationDirectionEnum;

using ProductIdentifierTypeEnum = Clusters::detail::ProductIdentifierTypeEnum;

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

namespace BooleanStateConfiguration {

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

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

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

namespace ValveConfigurationAndControl {

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

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

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

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

namespace ElectricalPowerMeasurement {

using MeasurementTypeEnum = Clusters::detail::MeasurementTypeEnum;

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

// Bitmap for Feature
enum class Feature : uint32_t {
kDirectCurrent = 0x1,
kAlternatingCurrent = 0x2,
kPolyphasePower = 0x4,
kHarmonics = 0x8,
kPowerQuality = 0x10,
};
} // namespace ElectricalPowerMeasurement

namespace ElectricalEnergyMeasurement {

using MeasurementTypeEnum = Clusters::detail::MeasurementTypeEnum;

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

namespace WaterHeaterManagement {

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

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

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

namespace DemandResponseLoadControl {

// Enum for CriticalityLevelEnum
enum class CriticalityLevelEnum : uint8_t {
kUnknown = 0x00,
kGreen = 0x01,
kLevel1 = 0x02,
kLevel2 = 0x03,
kLevel3 = 0x04,
kLevel4 = 0x05,
kLevel5 = 0x06,
kEmergency = 0x07,
kPlannedOutage = 0x08,
kServiceDisconnect = 0x09,
// All received enum values that are not listed above will be mapped
// to kUnknownEnumValue. This is a helper enum value that should only
// be used by code to process how it handles receiving and unknown
// enum value. This specific should never be transmitted.
kUnknownEnumValue = 10,
};

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

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

// Enum for LoadControlEventStatusEnum
enum class LoadControlEventStatusEnum : uint8_t {
kUnknown = 0x00,
kReceived = 0x01,
kInProgress = 0x02,
kCompleted = 0x03,
kOptedOut = 0x04,
kOptedIn = 0x05,
kCanceled = 0x06,
kSuperseded = 0x07,
kPartialOptedOut = 0x08,
kPartialOptedIn = 0x09,
kNoParticipation = 0x0A,
kUnavailable = 0x0B,
kFailed = 0x0C,
// All received enum values that are not listed above will be mapped
// to kUnknownEnumValue. This is a helper enum value that should only
// be used by code to process how it handles receiving and unknown
// enum value. This specific should never be transmitted.
kUnknownEnumValue = 13,
};

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

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

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

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

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

namespace Messages {

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

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

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

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

namespace DeviceEnergyManagement {

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

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

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

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

// Enum for ESATypeEnum
enum class ESATypeEnum : uint8_t {
kEvse = 0x00,
kSpaceHeating = 0x01,
kWaterHeating = 0x02,
kSpaceCooling = 0x03,
kSpaceHeatingCooling = 0x04,
kBatteryStorage = 0x05,
kSolarPV = 0x06,
kFridgeFreezer = 0x07,
kWashingMachine = 0x08,
kDishwasher = 0x09,
kCooking = 0x0A,
kHomeWaterPump = 0x0B,
kIrrigationWaterPump = 0x0C,
kPoolPump = 0x0D,
kOther = 0xFF,
// All received enum values that are not listed above will be mapped
// to kUnknownEnumValue. This is a helper enum value that should only
// be used by code to process how it handles receiving and unknown
// enum value. This specific should never be transmitted.
kUnknownEnumValue = 14,
};

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

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

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

// Bitmap for Feature
enum class Feature : uint32_t {
kPowerAdjustment = 0x1,
kPowerForecastReporting = 0x2,
kStateForecastReporting = 0x4,
kStartTimeAdjustment = 0x8,
kPausable = 0x10,
kForecastAdjustment = 0x20,
kConstraintBasedAdjustment = 0x40,
};
} // namespace DeviceEnergyManagement

namespace EnergyEvse {

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

// Enum for FaultStateEnum
enum class FaultStateEnum : uint8_t {
kNoError = 0x00,
kMeterFailure = 0x01,
kOverVoltage = 0x02,
kUnderVoltage = 0x03,
kOverCurrent = 0x04,
kContactWetFailure = 0x05,
kContactDryFailure = 0x06,
kGroundFault = 0x07,
kPowerLoss = 0x08,
kPowerQuality = 0x09,
kPilotShortCircuit = 0x0A,
kEmergencyStop = 0x0B,
kEVDisconnected = 0x0C,
kWrongPowerSupply = 0x0D,
kLiveNeutralSwap = 0x0E,
kOverTemperature = 0x0F,
kOther = 0xFF,
// All received enum values that are not listed above will be mapped
// to kUnknownEnumValue. This is a helper enum value that should only
// be used by code to process how it handles receiving and unknown
// enum value. This specific should never be transmitted.
kUnknownEnumValue = 16,
};

// Enum for StateEnum
enum class StateEnum : uint8_t {
kNotPluggedIn = 0x00,
kPluggedInNoDemand = 0x01,
kPluggedInDemand = 0x02,
kPluggedInCharging = 0x03,
kPluggedInDischarging = 0x04,
kSessionEnding = 0x05,
kFault = 0x06,
// All received enum values that are not listed above will be mapped
// to kUnknownEnumValue. This is a helper enum value that should only
// be used by code to process how it handles receiving and unknown
// enum value. This specific should never be transmitted.
kUnknownEnumValue = 7,
};

// Enum for SupplyStateEnum
enum class SupplyStateEnum : uint8_t {
kDisabled = 0x00,
kChargingEnabled = 0x01,
kDischargingEnabled = 0x02,
kDisabledError = 0x03,
kDisabledDiagnostics = 0x04,
kEnabled = 0x05,
// All received enum values that are not listed above will be mapped
// to kUnknownEnumValue. This is a helper enum value that should only
// be used by code to process how it handles receiving and unknown
// enum value. This specific should never be transmitted.
kUnknownEnumValue = 6,
};

// Bitmap for Feature
enum class Feature : uint32_t {
kChargingPreferences = 0x1,
kSoCReporting = 0x2,
kPlugAndCharge = 0x4,
kRfid = 0x8,
kV2x = 0x10,
};

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

namespace EnergyPreference {

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

// Bitmap for Feature
enum class Feature : uint32_t {
kEnergyBalance = 0x1,
kLowPowerModeSensitivity = 0x2,
};
} // namespace EnergyPreference

namespace PowerTopology {

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

namespace EnergyEvseMode {

// Enum for ModeTag
enum class ModeTag : uint16_t {
kAuto = 0x00,
kQuick = 0x01,
kQuiet = 0x02,
kLowNoise = 0x03,
kLowEnergy = 0x04,
kVacation = 0x05,
kMin = 0x06,
kMax = 0x07,
kNight = 0x08,
kDay = 0x09,
kManual = 0x4000,
kTimeOfUse = 0x4001,
kSolarCharging = 0x4002,
// kUnknownEnumValue intentionally not defined. This enum never goes
// through DataModel::Decode, likely because it is a part of a derived
// cluster. As a result having kUnknownEnumValue in this enum is error
// prone, and was removed. See
// src/app/common/templates/config-data.yaml.
};

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

namespace WaterHeaterMode {

// Enum for ModeTag
enum class ModeTag : uint16_t {
kAuto = 0x00,
kQuick = 0x01,
kQuiet = 0x02,
kLowNoise = 0x03,
kLowEnergy = 0x04,
kVacation = 0x05,
kMin = 0x06,
kMax = 0x07,
kNight = 0x08,
kDay = 0x09,
kOff = 0x4000,
kManual = 0x4001,
kTimed = 0x4002,
// kUnknownEnumValue intentionally not defined. This enum never goes
// through DataModel::Decode, likely because it is a part of a derived
// cluster. As a result having kUnknownEnumValue in this enum is error
// prone, and was removed. See
// src/app/common/templates/config-data.yaml.
};

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

namespace DeviceEnergyManagementMode {

// Enum for ModeTag
enum class ModeTag : uint16_t {
kAuto = 0x00,
kQuick = 0x01,
kQuiet = 0x02,
kLowNoise = 0x03,
kLowEnergy = 0x04,
kVacation = 0x05,
kMin = 0x06,
kMax = 0x07,
kNight = 0x08,
kDay = 0x09,
kNoOptimization = 0x4000,
kDeviceOptimization = 0x4001,
kLocalOptimization = 0x4002,
kGridOptimization = 0x4003,
// kUnknownEnumValue intentionally not defined. This enum never goes
// through DataModel::Decode, likely because it is a part of a derived
// cluster. As a result having kUnknownEnumValue in this enum is error
// prone, and was removed. See
// src/app/common/templates/config-data.yaml.
};

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

namespace DoorLock {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

namespace WindowCovering {

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

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

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

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

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

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

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

namespace ServiceArea {

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

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

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

// Bitmap for Feature
enum class Feature : uint32_t {
kSelectWhileRunning = 0x1,
kProgressReporting = 0x2,
kMaps = 0x4,
};
} // namespace ServiceArea

namespace PumpConfigurationAndControl {

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

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

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

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

namespace Thermostat {

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

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

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

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

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

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

// Enum for PresetScenarioEnum
enum class PresetScenarioEnum : uint8_t {
kOccupied = 0x01,
kUnoccupied = 0x02,
kSleep = 0x03,
kWake = 0x04,
kVacation = 0x05,
kGoingToSleep = 0x06,
kUserDefined = 0xFE,
// All received enum values that are not listed above will be mapped
// to kUnknownEnumValue. This is a helper enum value that should only
// be used by code to process how it handles receiving and unknown
// enum value. This specific should never be transmitted.
kUnknownEnumValue = 0,
};

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

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

// Enum for StartOfWeekEnum
enum class StartOfWeekEnum : uint8_t {
kSunday = 0x00,
kMonday = 0x01,
kTuesday = 0x02,
kWednesday = 0x03,
kThursday = 0x04,
kFriday = 0x05,
kSaturday = 0x06,
// All received enum values that are not listed above will be mapped
// to kUnknownEnumValue. This is a helper enum value that should only
// be used by code to process how it handles receiving and unknown
// enum value. This specific should never be transmitted.
kUnknownEnumValue = 7,
};

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

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

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

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

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

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

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

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

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

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

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

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

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

// Bitmap for ScheduleTypeFeaturesBitmap
enum class ScheduleTypeFeaturesBitmap : uint16_t {
kSupportsPresets = 0x1,
kSupportsSetpoints = 0x2,
kSupportsNames = 0x4,
kSupportsOff = 0x8,
};
} // namespace Thermostat

namespace FanControl {

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

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

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

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

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

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

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

namespace ThermostatUserInterfaceConfiguration {

// Enum for KeypadLockoutEnum
enum class KeypadLockoutEnum : uint8_t {
kNoLockout = 0x00,
kLockout1 = 0x01,
kLockout2 = 0x02,
kLockout3 = 0x03,
kLockout4 = 0x04,
kLockout5 = 0x05,
// All received enum values that are not listed above will be mapped
// to kUnknownEnumValue. This is a helper enum value that should only
// be used by code to process how it handles receiving and unknown
// enum value. This specific should never be transmitted.
kUnknownEnumValue = 6,
};

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

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

namespace ColorControl {

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

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

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

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

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

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

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

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

// Bitmap for ColorCapabilitiesBitmap
enum class ColorCapabilitiesBitmap : uint16_t {
kHueSaturation = 0x1,
kEnhancedHue = 0x2,
kColorLoop = 0x4,
kXy = 0x8,
kColorTemperature = 0x10,
};

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

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

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

namespace BallastConfiguration {

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

// Bitmap for LampAlarmModeBitmap
enum class LampAlarmModeBitmap : uint8_t {
kLampBurnHours = 0x1,
};
} // namespace BallastConfiguration

namespace IlluminanceMeasurement {

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

namespace TemperatureMeasurement {
} // namespace TemperatureMeasurement

namespace PressureMeasurement {

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

namespace FlowMeasurement {
} // namespace FlowMeasurement

namespace RelativeHumidityMeasurement {
} // namespace RelativeHumidityMeasurement

namespace OccupancySensing {

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

// Bitmap for Feature
enum class Feature : uint32_t {
kOther = 0x1,
kPassiveInfrared = 0x2,
kUltrasonic = 0x4,
kPhysicalContact = 0x8,
kActiveInfrared = 0x10,
kRadar = 0x20,
kRFSensing = 0x40,
kVision = 0x80,
};

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

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

namespace CarbonMonoxideConcentrationMeasurement {

using LevelValueEnum = Clusters::detail::LevelValueEnum;

using MeasurementMediumEnum = Clusters::detail::MeasurementMediumEnum;

using MeasurementUnitEnum = Clusters::detail::MeasurementUnitEnum;

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

namespace CarbonDioxideConcentrationMeasurement {

using LevelValueEnum = Clusters::detail::LevelValueEnum;

using MeasurementMediumEnum = Clusters::detail::MeasurementMediumEnum;

using MeasurementUnitEnum = Clusters::detail::MeasurementUnitEnum;

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

namespace NitrogenDioxideConcentrationMeasurement {

using LevelValueEnum = Clusters::detail::LevelValueEnum;

using MeasurementMediumEnum = Clusters::detail::MeasurementMediumEnum;

using MeasurementUnitEnum = Clusters::detail::MeasurementUnitEnum;

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

namespace OzoneConcentrationMeasurement {

using LevelValueEnum = Clusters::detail::LevelValueEnum;

using MeasurementMediumEnum = Clusters::detail::MeasurementMediumEnum;

using MeasurementUnitEnum = Clusters::detail::MeasurementUnitEnum;

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

namespace Pm25ConcentrationMeasurement {

using LevelValueEnum = Clusters::detail::LevelValueEnum;

using MeasurementMediumEnum = Clusters::detail::MeasurementMediumEnum;

using MeasurementUnitEnum = Clusters::detail::MeasurementUnitEnum;

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

namespace FormaldehydeConcentrationMeasurement {

using LevelValueEnum = Clusters::detail::LevelValueEnum;

using MeasurementMediumEnum = Clusters::detail::MeasurementMediumEnum;

using MeasurementUnitEnum = Clusters::detail::MeasurementUnitEnum;

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

namespace Pm1ConcentrationMeasurement {

using LevelValueEnum = Clusters::detail::LevelValueEnum;

using MeasurementMediumEnum = Clusters::detail::MeasurementMediumEnum;

using MeasurementUnitEnum = Clusters::detail::MeasurementUnitEnum;

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

namespace Pm10ConcentrationMeasurement {

using LevelValueEnum = Clusters::detail::LevelValueEnum;

using MeasurementMediumEnum = Clusters::detail::MeasurementMediumEnum;

using MeasurementUnitEnum = Clusters::detail::MeasurementUnitEnum;

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

namespace TotalVolatileOrganicCompoundsConcentrationMeasurement {

using LevelValueEnum = Clusters::detail::LevelValueEnum;

using MeasurementMediumEnum = Clusters::detail::MeasurementMediumEnum;

using MeasurementUnitEnum = Clusters::detail::MeasurementUnitEnum;

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

namespace RadonConcentrationMeasurement {

using LevelValueEnum = Clusters::detail::LevelValueEnum;

using MeasurementMediumEnum = Clusters::detail::MeasurementMediumEnum;

using MeasurementUnitEnum = Clusters::detail::MeasurementUnitEnum;

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

namespace WiFiNetworkManagement {
} // namespace WiFiNetworkManagement

namespace ThreadBorderRouterManagement {

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

namespace ThreadNetworkDirectory {
} // namespace ThreadNetworkDirectory

namespace WakeOnLan {
} // namespace WakeOnLan

namespace Channel {

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

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

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

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

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

namespace TargetNavigator {

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

namespace MediaPlayback {

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

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

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

// Bitmap for Feature
enum class Feature : uint32_t {
kAdvancedSeek = 0x1,
kVariableSpeed = 0x2,
kTextTracks = 0x4,
kAudioTracks = 0x8,
kAudioAdvance = 0x10,
};
} // namespace MediaPlayback

namespace MediaInput {

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

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

namespace LowPower {
} // namespace LowPower

namespace KeypadInput {

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

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

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

namespace ContentLauncher {

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

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

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

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

// Bitmap for Feature
enum class Feature : uint32_t {
kContentSearch = 0x1,
kURLPlayback = 0x2,
kAdvancedSeek = 0x4,
kTextTracks = 0x8,
kAudioTracks = 0x10,
};

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

namespace AudioOutput {

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

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

namespace ApplicationLauncher {

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

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

namespace ApplicationBasic {

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

namespace AccountLogin {
} // namespace AccountLogin

namespace ContentControl {

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

namespace ContentAppObserver {

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

namespace WebRTCTransportProvider {

using StreamTypeEnum = Clusters::detail::StreamTypeEnum;

using WebRTCEndReasonEnum = Clusters::detail::WebRTCEndReasonEnum;

using WebRTCMetadataOptions = Clusters::detail::WebRTCMetadataOptions;
} // namespace WebRTCTransportProvider

namespace Chime {
} // namespace Chime

namespace EcosystemInformation {
} // namespace EcosystemInformation

namespace CommissionerControl {

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

namespace UnitTesting {

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

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

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

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

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

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

namespace FaultInjection {

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

namespace SampleMei {
} // namespace SampleMei

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

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