/*
 *
 *    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 <app-common/zap-generated/cluster-enums.h>

namespace chip {
namespace app {
namespace Clusters {
static auto __attribute__((unused)) EnsureKnownEnumValue(Identify::IdentifyEffectIdentifier val)
{
    using EnumType = Identify::IdentifyEffectIdentifier;
    switch (val)
    {
// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EnumType::kBlink:
    case EnumType::kBreathe:
    case EnumType::kOkay:
    case EnumType::kChannelChange:
    case EnumType::kFinishEffect:
    case EnumType::kStopEffect:
#else  // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_BLINK:
    case EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_BREATHE:
    case EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_OKAY:
    case EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_CHANNEL_CHANGE:
    case EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_FINISH_EFFECT:
    case EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_STOP_EFFECT:
#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
        return val;
    default:
        return static_cast<EnumType>(3);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(Identify::IdentifyEffectVariant val)
{
    using EnumType = Identify::IdentifyEffectVariant;
    switch (val)
    {
// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EnumType::kDefault:
#else  // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EMBER_ZCL_IDENTIFY_EFFECT_VARIANT_DEFAULT:
#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
        return val;
    default:
        return static_cast<EnumType>(1);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(Identify::IdentifyIdentifyType val)
{
    using EnumType = Identify::IdentifyIdentifyType;
    switch (val)
    {
// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EnumType::kNone:
    case EnumType::kVisibleLight:
    case EnumType::kVisibleLED:
    case EnumType::kAudibleBeep:
    case EnumType::kDisplay:
    case EnumType::kActuator:
#else  // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EMBER_ZCL_IDENTIFY_IDENTIFY_TYPE_NONE:
    case EMBER_ZCL_IDENTIFY_IDENTIFY_TYPE_VISIBLE_LIGHT:
    case EMBER_ZCL_IDENTIFY_IDENTIFY_TYPE_VISIBLE_LED:
    case EMBER_ZCL_IDENTIFY_IDENTIFY_TYPE_AUDIBLE_BEEP:
    case EMBER_ZCL_IDENTIFY_IDENTIFY_TYPE_DISPLAY:
    case EMBER_ZCL_IDENTIFY_IDENTIFY_TYPE_ACTUATOR:
#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
        return val;
    default:
        return static_cast<EnumType>(6);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(OnOff::OnOffDelayedAllOffEffectVariant val)
{
    using EnumType = OnOff::OnOffDelayedAllOffEffectVariant;
    switch (val)
    {
// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EnumType::kFadeToOffIn0p8Seconds:
    case EnumType::kNoFade:
    case EnumType::k50PercentDimDownIn0p8SecondsThenFadeToOffIn12Seconds:
#else  // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EMBER_ZCL_ON_OFF_DELAYED_ALL_OFF_EFFECT_VARIANT_FADE_TO_OFF_IN_0P8_SECONDS:
    case EMBER_ZCL_ON_OFF_DELAYED_ALL_OFF_EFFECT_VARIANT_NO_FADE:
    case EMBER_ZCL_ON_OFF_DELAYED_ALL_OFF_EFFECT_VARIANT_50_PERCENT_DIM_DOWN_IN_0P8_SECONDS_THEN_FADE_TO_OFF_IN_12_SECONDS:
#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
        return val;
    default:
        return static_cast<EnumType>(3);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(OnOff::OnOffDyingLightEffectVariant val)
{
    using EnumType = OnOff::OnOffDyingLightEffectVariant;
    switch (val)
    {
// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EnumType::k20PercenterDimUpIn0p5SecondsThenFadeToOffIn1Second:
#else  // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EMBER_ZCL_ON_OFF_DYING_LIGHT_EFFECT_VARIANT_20_PERCENTER_DIM_UP_IN_0P5_SECONDS_THEN_FADE_TO_OFF_IN_1_SECOND:
#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
        return val;
    default:
        return static_cast<EnumType>(1);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(OnOff::OnOffEffectIdentifier val)
{
    using EnumType = OnOff::OnOffEffectIdentifier;
    switch (val)
    {
// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EnumType::kDelayedAllOff:
    case EnumType::kDyingLight:
#else  // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EMBER_ZCL_ON_OFF_EFFECT_IDENTIFIER_DELAYED_ALL_OFF:
    case EMBER_ZCL_ON_OFF_EFFECT_IDENTIFIER_DYING_LIGHT:
#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
        return val;
    default:
        return static_cast<EnumType>(2);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(OnOff::OnOffStartUpOnOff val)
{
    using EnumType = OnOff::OnOffStartUpOnOff;
    switch (val)
    {
    case EnumType::kOff:
    case EnumType::kOn:
    case EnumType::kTogglePreviousOnOff:
        return val;
    default:
        return static_cast<EnumType>(3);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(LevelControl::MoveMode val)
{
    using EnumType = LevelControl::MoveMode;
    switch (val)
    {
// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EnumType::kUp:
    case EnumType::kDown:
#else  // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EMBER_ZCL_MOVE_MODE_UP:
    case EMBER_ZCL_MOVE_MODE_DOWN:
#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
        return val;
    default:
        return static_cast<EnumType>(2);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(LevelControl::StepMode val)
{
    using EnumType = LevelControl::StepMode;
    switch (val)
    {
// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EnumType::kUp:
    case EnumType::kDown:
#else  // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EMBER_ZCL_STEP_MODE_UP:
    case EMBER_ZCL_STEP_MODE_DOWN:
#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
        return val;
    default:
        return static_cast<EnumType>(2);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(AccessControl::AccessControlEntryAuthModeEnum val)
{
    using EnumType = AccessControl::AccessControlEntryAuthModeEnum;
    switch (val)
    {
    case EnumType::kPase:
    case EnumType::kCase:
    case EnumType::kGroup:
        return val;
    default:
        return static_cast<EnumType>(0);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(AccessControl::AccessControlEntryPrivilegeEnum val)
{
    using EnumType = AccessControl::AccessControlEntryPrivilegeEnum;
    switch (val)
    {
    case EnumType::kView:
    case EnumType::kProxyView:
    case EnumType::kOperate:
    case EnumType::kManage:
    case EnumType::kAdminister:
        return val;
    default:
        return static_cast<EnumType>(0);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(AccessControl::ChangeTypeEnum val)
{
    using EnumType = AccessControl::ChangeTypeEnum;
    switch (val)
    {
    case EnumType::kChanged:
    case EnumType::kAdded:
    case EnumType::kRemoved:
        return val;
    default:
        return static_cast<EnumType>(3);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(Actions::ActionErrorEnum val)
{
    using EnumType = Actions::ActionErrorEnum;
    switch (val)
    {
    case EnumType::kUnknown:
    case EnumType::kInterrupted:
        return val;
    default:
        return static_cast<EnumType>(2);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(Actions::ActionStateEnum val)
{
    using EnumType = Actions::ActionStateEnum;
    switch (val)
    {
    case EnumType::kInactive:
    case EnumType::kActive:
    case EnumType::kPaused:
    case EnumType::kDisabled:
        return val;
    default:
        return static_cast<EnumType>(4);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(Actions::ActionTypeEnum val)
{
    using EnumType = Actions::ActionTypeEnum;
    switch (val)
    {
    case EnumType::kOther:
    case EnumType::kScene:
    case EnumType::kSequence:
    case EnumType::kAutomation:
    case EnumType::kException:
    case EnumType::kNotification:
    case EnumType::kAlarm:
        return val;
    default:
        return static_cast<EnumType>(7);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(Actions::EndpointListTypeEnum val)
{
    using EnumType = Actions::EndpointListTypeEnum;
    switch (val)
    {
    case EnumType::kOther:
    case EnumType::kRoom:
    case EnumType::kZone:
        return val;
    default:
        return static_cast<EnumType>(3);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(OtaSoftwareUpdateProvider::OTAApplyUpdateAction val)
{
    using EnumType = OtaSoftwareUpdateProvider::OTAApplyUpdateAction;
    switch (val)
    {
    case EnumType::kProceed:
    case EnumType::kAwaitNextAction:
    case EnumType::kDiscontinue:
        return val;
    default:
        return static_cast<EnumType>(3);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(OtaSoftwareUpdateProvider::OTADownloadProtocol val)
{
    using EnumType = OtaSoftwareUpdateProvider::OTADownloadProtocol;
    switch (val)
    {
    case EnumType::kBDXSynchronous:
    case EnumType::kBDXAsynchronous:
    case EnumType::kHttps:
    case EnumType::kVendorSpecific:
        return val;
    default:
        return static_cast<EnumType>(4);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(OtaSoftwareUpdateProvider::OTAQueryStatus val)
{
    using EnumType = OtaSoftwareUpdateProvider::OTAQueryStatus;
    switch (val)
    {
    case EnumType::kUpdateAvailable:
    case EnumType::kBusy:
    case EnumType::kNotAvailable:
    case EnumType::kDownloadProtocolNotSupported:
        return val;
    default:
        return static_cast<EnumType>(4);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(OtaSoftwareUpdateRequestor::OTAAnnouncementReason val)
{
    using EnumType = OtaSoftwareUpdateRequestor::OTAAnnouncementReason;
    switch (val)
    {
    case EnumType::kSimpleAnnouncement:
    case EnumType::kUpdateAvailable:
    case EnumType::kUrgentUpdateAvailable:
        return val;
    default:
        return static_cast<EnumType>(3);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(OtaSoftwareUpdateRequestor::OTAChangeReasonEnum val)
{
    using EnumType = OtaSoftwareUpdateRequestor::OTAChangeReasonEnum;
    switch (val)
    {
    case EnumType::kUnknown:
    case EnumType::kSuccess:
    case EnumType::kFailure:
    case EnumType::kTimeOut:
    case EnumType::kDelayByProvider:
        return val;
    default:
        return static_cast<EnumType>(5);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(OtaSoftwareUpdateRequestor::OTAUpdateStateEnum val)
{
    using EnumType = OtaSoftwareUpdateRequestor::OTAUpdateStateEnum;
    switch (val)
    {
    case EnumType::kUnknown:
    case EnumType::kIdle:
    case EnumType::kQuerying:
    case EnumType::kDelayedOnQuery:
    case EnumType::kDownloading:
    case EnumType::kApplying:
    case EnumType::kDelayedOnApply:
    case EnumType::kRollingBack:
    case EnumType::kDelayedOnUserConsent:
        return val;
    default:
        return static_cast<EnumType>(9);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(TimeFormatLocalization::CalendarType val)
{
    using EnumType = TimeFormatLocalization::CalendarType;
    switch (val)
    {
    case EnumType::kBuddhist:
    case EnumType::kChinese:
    case EnumType::kCoptic:
    case EnumType::kEthiopian:
    case EnumType::kGregorian:
    case EnumType::kHebrew:
    case EnumType::kIndian:
    case EnumType::kIslamic:
    case EnumType::kJapanese:
    case EnumType::kKorean:
    case EnumType::kPersian:
    case EnumType::kTaiwanese:
        return val;
    default:
        return static_cast<EnumType>(12);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(TimeFormatLocalization::HourFormat val)
{
    using EnumType = TimeFormatLocalization::HourFormat;
    switch (val)
    {
    case EnumType::k12hr:
    case EnumType::k24hr:
        return val;
    default:
        return static_cast<EnumType>(2);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(UnitLocalization::TempUnit val)
{
    using EnumType = UnitLocalization::TempUnit;
    switch (val)
    {
    case EnumType::kFahrenheit:
    case EnumType::kCelsius:
    case EnumType::kKelvin:
        return val;
    default:
        return static_cast<EnumType>(3);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(PowerSource::BatChargeFault val)
{
    using EnumType = PowerSource::BatChargeFault;
    switch (val)
    {
    case EnumType::kUnspecfied:
    case EnumType::kAmbientTooHot:
    case EnumType::kAmbientTooCold:
    case EnumType::kBatteryTooHot:
    case EnumType::kBatteryTooCold:
    case EnumType::kBatteryAbsent:
    case EnumType::kBatteryOverVoltage:
    case EnumType::kBatteryUnderVoltage:
    case EnumType::kChargerOverVoltage:
    case EnumType::kChargerUnderVoltage:
    case EnumType::kSafetyTimeout:
        return val;
    default:
        return static_cast<EnumType>(11);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(PowerSource::BatChargeLevel val)
{
    using EnumType = PowerSource::BatChargeLevel;
    switch (val)
    {
    case EnumType::kOk:
    case EnumType::kWarning:
    case EnumType::kCritical:
        return val;
    default:
        return static_cast<EnumType>(3);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(PowerSource::BatChargeState val)
{
    using EnumType = PowerSource::BatChargeState;
    switch (val)
    {
    case EnumType::kUnknown:
    case EnumType::kIsCharging:
    case EnumType::kIsAtFullCharge:
    case EnumType::kIsNotCharging:
        return val;
    default:
        return static_cast<EnumType>(4);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(PowerSource::BatFault val)
{
    using EnumType = PowerSource::BatFault;
    switch (val)
    {
    case EnumType::kUnspecfied:
    case EnumType::kOverTemp:
    case EnumType::kUnderTemp:
        return val;
    default:
        return static_cast<EnumType>(3);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(PowerSource::BatReplaceability val)
{
    using EnumType = PowerSource::BatReplaceability;
    switch (val)
    {
    case EnumType::kUnspecified:
    case EnumType::kNotReplaceable:
    case EnumType::kUserReplaceable:
    case EnumType::kFactoryReplaceable:
        return val;
    default:
        return static_cast<EnumType>(4);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(PowerSource::PowerSourceStatus val)
{
    using EnumType = PowerSource::PowerSourceStatus;
    switch (val)
    {
    case EnumType::kUnspecfied:
    case EnumType::kActive:
    case EnumType::kStandby:
    case EnumType::kUnavailable:
        return val;
    default:
        return static_cast<EnumType>(4);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(PowerSource::WiredCurrentType val)
{
    using EnumType = PowerSource::WiredCurrentType;
    switch (val)
    {
    case EnumType::kAc:
    case EnumType::kDc:
        return val;
    default:
        return static_cast<EnumType>(2);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(PowerSource::WiredFault val)
{
    using EnumType = PowerSource::WiredFault;
    switch (val)
    {
    case EnumType::kUnspecfied:
    case EnumType::kOverVoltage:
    case EnumType::kUnderVoltage:
        return val;
    default:
        return static_cast<EnumType>(3);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(GeneralCommissioning::CommissioningError val)
{
    using EnumType = GeneralCommissioning::CommissioningError;
    switch (val)
    {
    case EnumType::kOk:
    case EnumType::kValueOutsideRange:
    case EnumType::kInvalidAuthentication:
    case EnumType::kNoFailSafe:
    case EnumType::kBusyWithOtherAdmin:
        return val;
    default:
        return static_cast<EnumType>(5);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(GeneralCommissioning::RegulatoryLocationType val)
{
    using EnumType = GeneralCommissioning::RegulatoryLocationType;
    switch (val)
    {
    case EnumType::kIndoor:
    case EnumType::kOutdoor:
    case EnumType::kIndoorOutdoor:
        return val;
    default:
        return static_cast<EnumType>(3);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(NetworkCommissioning::NetworkCommissioningStatus val)
{
    using EnumType = NetworkCommissioning::NetworkCommissioningStatus;
    switch (val)
    {
    case EnumType::kSuccess:
    case EnumType::kOutOfRange:
    case EnumType::kBoundsExceeded:
    case EnumType::kNetworkIDNotFound:
    case EnumType::kDuplicateNetworkID:
    case EnumType::kNetworkNotFound:
    case EnumType::kRegulatoryError:
    case EnumType::kAuthFailure:
    case EnumType::kUnsupportedSecurity:
    case EnumType::kOtherConnectionFailure:
    case EnumType::kIPV6Failed:
    case EnumType::kIPBindFailed:
    case EnumType::kUnknownError:
        return val;
    default:
        return static_cast<EnumType>(13);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(NetworkCommissioning::WiFiBand val)
{
    using EnumType = NetworkCommissioning::WiFiBand;
    switch (val)
    {
    case EnumType::k2g4:
    case EnumType::k3g65:
    case EnumType::k5g:
    case EnumType::k6g:
    case EnumType::k60g:
        return val;
    default:
        return static_cast<EnumType>(5);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(DiagnosticLogs::LogsIntent val)
{
    using EnumType = DiagnosticLogs::LogsIntent;
    switch (val)
    {
    case EnumType::kEndUserSupport:
    case EnumType::kNetworkDiag:
    case EnumType::kCrashLogs:
        return val;
    default:
        return static_cast<EnumType>(3);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(DiagnosticLogs::LogsStatus val)
{
    using EnumType = DiagnosticLogs::LogsStatus;
    switch (val)
    {
    case EnumType::kSuccess:
    case EnumType::kExhausted:
    case EnumType::kNoLogs:
    case EnumType::kBusy:
    case EnumType::kDenied:
        return val;
    default:
        return static_cast<EnumType>(5);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(DiagnosticLogs::LogsTransferProtocol val)
{
    using EnumType = DiagnosticLogs::LogsTransferProtocol;
    switch (val)
    {
    case EnumType::kResponsePayload:
    case EnumType::kBdx:
        return val;
    default:
        return static_cast<EnumType>(2);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(GeneralDiagnostics::BootReasonEnum val)
{
    using EnumType = GeneralDiagnostics::BootReasonEnum;
    switch (val)
    {
    case EnumType::kUnspecified:
    case EnumType::kPowerOnReboot:
    case EnumType::kBrownOutReset:
    case EnumType::kSoftwareWatchdogReset:
    case EnumType::kHardwareWatchdogReset:
    case EnumType::kSoftwareUpdateCompleted:
    case EnumType::kSoftwareReset:
        return val;
    default:
        return static_cast<EnumType>(7);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(GeneralDiagnostics::HardwareFaultEnum val)
{
    using EnumType = GeneralDiagnostics::HardwareFaultEnum;
    switch (val)
    {
// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EnumType::kUnspecified:
    case EnumType::kRadio:
    case EnumType::kSensor:
    case EnumType::kResettableOverTemp:
    case EnumType::kNonResettableOverTemp:
    case EnumType::kPowerSource:
    case EnumType::kVisualDisplayFault:
    case EnumType::kAudioOutputFault:
    case EnumType::kUserInterfaceFault:
    case EnumType::kNonVolatileMemoryError:
    case EnumType::kTamperDetected:
#else  // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EMBER_ZCL_HARDWARE_FAULT_ENUM_UNSPECIFIED:
    case EMBER_ZCL_HARDWARE_FAULT_ENUM_RADIO:
    case EMBER_ZCL_HARDWARE_FAULT_ENUM_SENSOR:
    case EMBER_ZCL_HARDWARE_FAULT_ENUM_RESETTABLE_OVER_TEMP:
    case EMBER_ZCL_HARDWARE_FAULT_ENUM_NON_RESETTABLE_OVER_TEMP:
    case EMBER_ZCL_HARDWARE_FAULT_ENUM_POWER_SOURCE:
    case EMBER_ZCL_HARDWARE_FAULT_ENUM_VISUAL_DISPLAY_FAULT:
    case EMBER_ZCL_HARDWARE_FAULT_ENUM_AUDIO_OUTPUT_FAULT:
    case EMBER_ZCL_HARDWARE_FAULT_ENUM_USER_INTERFACE_FAULT:
    case EMBER_ZCL_HARDWARE_FAULT_ENUM_NON_VOLATILE_MEMORY_ERROR:
    case EMBER_ZCL_HARDWARE_FAULT_ENUM_TAMPER_DETECTED:
#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
        return val;
    default:
        return static_cast<EnumType>(11);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(GeneralDiagnostics::InterfaceTypeEnum val)
{
    using EnumType = GeneralDiagnostics::InterfaceTypeEnum;
    switch (val)
    {
// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EnumType::kUnspecified:
    case EnumType::kWiFi:
    case EnumType::kEthernet:
    case EnumType::kCellular:
    case EnumType::kThread:
#else  // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EMBER_ZCL_INTERFACE_TYPE_ENUM_UNSPECIFIED:
    case EMBER_ZCL_INTERFACE_TYPE_ENUM_WI_FI:
    case EMBER_ZCL_INTERFACE_TYPE_ENUM_ETHERNET:
    case EMBER_ZCL_INTERFACE_TYPE_ENUM_CELLULAR:
    case EMBER_ZCL_INTERFACE_TYPE_ENUM_THREAD:
#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
        return val;
    default:
        return static_cast<EnumType>(5);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(GeneralDiagnostics::NetworkFaultEnum val)
{
    using EnumType = GeneralDiagnostics::NetworkFaultEnum;
    switch (val)
    {
// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EnumType::kUnspecified:
    case EnumType::kHardwareFailure:
    case EnumType::kNetworkJammed:
    case EnumType::kConnectionFailed:
#else  // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EMBER_ZCL_NETWORK_FAULT_ENUM_UNSPECIFIED:
    case EMBER_ZCL_NETWORK_FAULT_ENUM_HARDWARE_FAILURE:
    case EMBER_ZCL_NETWORK_FAULT_ENUM_NETWORK_JAMMED:
    case EMBER_ZCL_NETWORK_FAULT_ENUM_CONNECTION_FAILED:
#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
        return val;
    default:
        return static_cast<EnumType>(4);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(GeneralDiagnostics::RadioFaultEnum val)
{
    using EnumType = GeneralDiagnostics::RadioFaultEnum;
    switch (val)
    {
// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EnumType::kUnspecified:
    case EnumType::kWiFiFault:
    case EnumType::kCellularFault:
    case EnumType::kThreadFault:
    case EnumType::kNFCFault:
    case EnumType::kBLEFault:
    case EnumType::kEthernetFault:
#else  // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EMBER_ZCL_RADIO_FAULT_ENUM_UNSPECIFIED:
    case EMBER_ZCL_RADIO_FAULT_ENUM_WI_FI_FAULT:
    case EMBER_ZCL_RADIO_FAULT_ENUM_CELLULAR_FAULT:
    case EMBER_ZCL_RADIO_FAULT_ENUM_THREAD_FAULT:
    case EMBER_ZCL_RADIO_FAULT_ENUM_NFC_FAULT:
    case EMBER_ZCL_RADIO_FAULT_ENUM_BLE_FAULT:
    case EMBER_ZCL_RADIO_FAULT_ENUM_ETHERNET_FAULT:
#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
        return val;
    default:
        return static_cast<EnumType>(7);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(ThreadNetworkDiagnostics::ConnectionStatusEnum val)
{
    using EnumType = ThreadNetworkDiagnostics::ConnectionStatusEnum;
    switch (val)
    {
    case EnumType::kConnected:
    case EnumType::kNotConnected:
        return val;
    default:
        return static_cast<EnumType>(2);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(ThreadNetworkDiagnostics::NetworkFault val)
{
    using EnumType = ThreadNetworkDiagnostics::NetworkFault;
    switch (val)
    {
    case EnumType::kUnspecified:
    case EnumType::kLinkDown:
    case EnumType::kHardwareFailure:
    case EnumType::kNetworkJammed:
        return val;
    default:
        return static_cast<EnumType>(4);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(ThreadNetworkDiagnostics::RoutingRole val)
{
    using EnumType = ThreadNetworkDiagnostics::RoutingRole;
    switch (val)
    {
// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EnumType::kUnspecified:
    case EnumType::kUnassigned:
    case EnumType::kSleepyEndDevice:
    case EnumType::kEndDevice:
    case EnumType::kReed:
    case EnumType::kRouter:
    case EnumType::kLeader:
#else  // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EMBER_ZCL_ROUTING_ROLE_UNSPECIFIED:
    case EMBER_ZCL_ROUTING_ROLE_UNASSIGNED:
    case EMBER_ZCL_ROUTING_ROLE_SLEEPY_END_DEVICE:
    case EMBER_ZCL_ROUTING_ROLE_END_DEVICE:
    case EMBER_ZCL_ROUTING_ROLE_REED:
    case EMBER_ZCL_ROUTING_ROLE_ROUTER:
    case EMBER_ZCL_ROUTING_ROLE_LEADER:
#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
        return val;
    default:
        return static_cast<EnumType>(7);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(WiFiNetworkDiagnostics::AssociationFailureCause val)
{
    using EnumType = WiFiNetworkDiagnostics::AssociationFailureCause;
    switch (val)
    {
    case EnumType::kUnknown:
    case EnumType::kAssociationFailed:
    case EnumType::kAuthenticationFailed:
    case EnumType::kSsidNotFound:
        return val;
    default:
        return static_cast<EnumType>(4);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(WiFiNetworkDiagnostics::SecurityType val)
{
    using EnumType = WiFiNetworkDiagnostics::SecurityType;
    switch (val)
    {
// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EnumType::kUnspecified:
    case EnumType::kNone:
    case EnumType::kWep:
    case EnumType::kWpa:
    case EnumType::kWpa2:
    case EnumType::kWpa3:
#else  // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EMBER_ZCL_SECURITY_TYPE_UNSPECIFIED:
    case EMBER_ZCL_SECURITY_TYPE_NONE:
    case EMBER_ZCL_SECURITY_TYPE_WEP:
    case EMBER_ZCL_SECURITY_TYPE_WPA:
    case EMBER_ZCL_SECURITY_TYPE_WPA2:
    case EMBER_ZCL_SECURITY_TYPE_WPA3:
#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
        return val;
    default:
        return static_cast<EnumType>(6);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(WiFiNetworkDiagnostics::WiFiConnectionStatus val)
{
    using EnumType = WiFiNetworkDiagnostics::WiFiConnectionStatus;
    switch (val)
    {
    case EnumType::kConnected:
    case EnumType::kNotConnected:
        return val;
    default:
        return static_cast<EnumType>(2);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(WiFiNetworkDiagnostics::WiFiVersionType val)
{
    using EnumType = WiFiNetworkDiagnostics::WiFiVersionType;
    switch (val)
    {
// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EnumType::kA:
    case EnumType::kB:
    case EnumType::kG:
    case EnumType::kN:
    case EnumType::kAc:
    case EnumType::kAx:
#else  // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EMBER_ZCL_WI_FI_VERSION_TYPE_A:
    case EMBER_ZCL_WI_FI_VERSION_TYPE_B:
    case EMBER_ZCL_WI_FI_VERSION_TYPE_G:
    case EMBER_ZCL_WI_FI_VERSION_TYPE_N:
    case EMBER_ZCL_WI_FI_VERSION_TYPE_AC:
    case EMBER_ZCL_WI_FI_VERSION_TYPE_AX:
#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
        return val;
    default:
        return static_cast<EnumType>(6);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(EthernetNetworkDiagnostics::PHYRateEnum val)
{
    using EnumType = EthernetNetworkDiagnostics::PHYRateEnum;
    switch (val)
    {
// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EnumType::kRate10M:
    case EnumType::kRate100M:
    case EnumType::kRate1G:
    case EnumType::kRate25g:
    case EnumType::kRate5G:
    case EnumType::kRate10G:
    case EnumType::kRate40G:
    case EnumType::kRate100G:
    case EnumType::kRate200G:
    case EnumType::kRate400G:
#else  // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EMBER_ZCL_PHY_RATE_ENUM_RATE10_M:
    case EMBER_ZCL_PHY_RATE_ENUM_RATE100_M:
    case EMBER_ZCL_PHY_RATE_ENUM_RATE1_G:
    case EMBER_ZCL_PHY_RATE_ENUM_RATE2_5_G:
    case EMBER_ZCL_PHY_RATE_ENUM_RATE5_G:
    case EMBER_ZCL_PHY_RATE_ENUM_RATE10_G:
    case EMBER_ZCL_PHY_RATE_ENUM_RATE40_G:
    case EMBER_ZCL_PHY_RATE_ENUM_RATE100_G:
    case EMBER_ZCL_PHY_RATE_ENUM_RATE200_G:
    case EMBER_ZCL_PHY_RATE_ENUM_RATE400_G:
#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
        return val;
    default:
        return static_cast<EnumType>(10);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(TimeSynchronization::GranularityEnum val)
{
    using EnumType = TimeSynchronization::GranularityEnum;
    switch (val)
    {
    case EnumType::kNoTimeGranularity:
    case EnumType::kMinutesGranularity:
    case EnumType::kSecondsGranularity:
    case EnumType::kMillisecondsGranularity:
    case EnumType::kMicrosecondsGranularity:
        return val;
    default:
        return static_cast<EnumType>(5);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(TimeSynchronization::TimeSourceEnum val)
{
    using EnumType = TimeSynchronization::TimeSourceEnum;
    switch (val)
    {
    case EnumType::kNone:
    case EnumType::kUnknown:
    case EnumType::kAdmin:
    case EnumType::kNodeTimeCluster:
    case EnumType::kNonFabricSntp:
    case EnumType::kNonFabricNtp:
    case EnumType::kFabricSntp:
    case EnumType::kFabricNtp:
    case EnumType::kMixedNtp:
    case EnumType::kNonFabricSntpNts:
    case EnumType::kNonFabricNtpNts:
    case EnumType::kFabricSntpNts:
    case EnumType::kFabricNtpNts:
    case EnumType::kMixedNtpNts:
    case EnumType::kCloudSource:
    case EnumType::kPtp:
    case EnumType::kGnss:
        return val;
    default:
        return static_cast<EnumType>(17);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(AdministratorCommissioning::CommissioningWindowStatusEnum val)
{
    using EnumType = AdministratorCommissioning::CommissioningWindowStatusEnum;
    switch (val)
    {
    case EnumType::kWindowNotOpen:
    case EnumType::kEnhancedWindowOpen:
    case EnumType::kBasicWindowOpen:
        return val;
    default:
        return static_cast<EnumType>(3);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(AdministratorCommissioning::StatusCode val)
{
    using EnumType = AdministratorCommissioning::StatusCode;
    switch (val)
    {
// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EnumType::kBusy:
    case EnumType::kPAKEParameterError:
    case EnumType::kWindowNotOpen:
#else  // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EMBER_ZCL_STATUS_CODE_BUSY:
    case EMBER_ZCL_STATUS_CODE_PAKE_PARAMETER_ERROR:
    case EMBER_ZCL_STATUS_CODE_WINDOW_NOT_OPEN:
#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
        return val;
    default:
        return static_cast<EnumType>(0);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(OperationalCredentials::CertificateChainTypeEnum val)
{
    using EnumType = OperationalCredentials::CertificateChainTypeEnum;
    switch (val)
    {
    case EnumType::kDACCertificate:
    case EnumType::kPAICertificate:
        return val;
    default:
        return static_cast<EnumType>(0);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(OperationalCredentials::NodeOperationalCertStatusEnum val)
{
    using EnumType = OperationalCredentials::NodeOperationalCertStatusEnum;
    switch (val)
    {
    case EnumType::kOk:
    case EnumType::kInvalidPublicKey:
    case EnumType::kInvalidNodeOpId:
    case EnumType::kInvalidNOC:
    case EnumType::kMissingCsr:
    case EnumType::kTableFull:
    case EnumType::kInvalidAdminSubject:
    case EnumType::kFabricConflict:
    case EnumType::kLabelConflict:
    case EnumType::kInvalidFabricIndex:
        return val;
    default:
        return static_cast<EnumType>(7);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(GroupKeyManagement::GroupKeySecurityPolicy val)
{
    using EnumType = GroupKeyManagement::GroupKeySecurityPolicy;
    switch (val)
    {
    case EnumType::kTrustFirst:
    case EnumType::kCacheAndSync:
        return val;
    default:
        return static_cast<EnumType>(2);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::AlarmCodeEnum val)
{
    using EnumType = DoorLock::AlarmCodeEnum;
    switch (val)
    {
    case EnumType::kLockJammed:
    case EnumType::kLockFactoryReset:
    case EnumType::kLockRadioPowerCycled:
    case EnumType::kWrongCodeEntryLimit:
    case EnumType::kFrontEsceutcheonRemoved:
    case EnumType::kDoorForcedOpen:
    case EnumType::kDoorAjar:
    case EnumType::kForcedUser:
        return val;
    default:
        return static_cast<EnumType>(2);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::CredentialRuleEnum val)
{
    using EnumType = DoorLock::CredentialRuleEnum;
    switch (val)
    {
    case EnumType::kSingle:
    case EnumType::kDual:
    case EnumType::kTri:
        return val;
    default:
        return static_cast<EnumType>(3);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::CredentialTypeEnum val)
{
    using EnumType = DoorLock::CredentialTypeEnum;
    switch (val)
    {
    case EnumType::kProgrammingPIN:
    case EnumType::kPin:
    case EnumType::kRfid:
    case EnumType::kFingerprint:
    case EnumType::kFingerVein:
    case EnumType::kFace:
        return val;
    default:
        return static_cast<EnumType>(6);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DataOperationTypeEnum val)
{
    using EnumType = DoorLock::DataOperationTypeEnum;
    switch (val)
    {
    case EnumType::kAdd:
    case EnumType::kClear:
    case EnumType::kModify:
        return val;
    default:
        return static_cast<EnumType>(3);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DlLockState val)
{
    using EnumType = DoorLock::DlLockState;
    switch (val)
    {
    case EnumType::kNotFullyLocked:
    case EnumType::kLocked:
    case EnumType::kUnlocked:
        return val;
    default:
        return static_cast<EnumType>(3);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DlLockType val)
{
    using EnumType = DoorLock::DlLockType;
    switch (val)
    {
    case EnumType::kDeadBolt:
    case EnumType::kMagnetic:
    case EnumType::kOther:
    case EnumType::kMortise:
    case EnumType::kRim:
    case EnumType::kLatchBolt:
    case EnumType::kCylindricalLock:
    case EnumType::kTubularLock:
    case EnumType::kInterconnectedLock:
    case EnumType::kDeadLatch:
    case EnumType::kDoorFurniture:
        return val;
    default:
        return static_cast<EnumType>(11);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DlStatus val)
{
    using EnumType = DoorLock::DlStatus;
    switch (val)
    {
    case EnumType::kSuccess:
    case EnumType::kFailure:
    case EnumType::kDuplicate:
    case EnumType::kOccupied:
    case EnumType::kInvalidField:
    case EnumType::kResourceExhausted:
    case EnumType::kNotFound:
        return val;
    default:
        return static_cast<EnumType>(4);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DoorLockOperationEventCode val)
{
    using EnumType = DoorLock::DoorLockOperationEventCode;
    switch (val)
    {
    case EnumType::kUnknownOrMfgSpecific:
    case EnumType::kLock:
    case EnumType::kUnlock:
    case EnumType::kLockInvalidPinOrId:
    case EnumType::kLockInvalidSchedule:
    case EnumType::kUnlockInvalidPinOrId:
    case EnumType::kUnlockInvalidSchedule:
    case EnumType::kOneTouchLock:
    case EnumType::kKeyLock:
    case EnumType::kKeyUnlock:
    case EnumType::kAutoLock:
    case EnumType::kScheduleLock:
    case EnumType::kScheduleUnlock:
    case EnumType::kManualLock:
    case EnumType::kManualUnlock:
        return val;
    default:
        return static_cast<EnumType>(15);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DoorLockProgrammingEventCode val)
{
    using EnumType = DoorLock::DoorLockProgrammingEventCode;
    switch (val)
    {
    case EnumType::kUnknownOrMfgSpecific:
    case EnumType::kMasterCodeChanged:
    case EnumType::kPinAdded:
    case EnumType::kPinDeleted:
    case EnumType::kPinChanged:
    case EnumType::kIdAdded:
    case EnumType::kIdDeleted:
        return val;
    default:
        return static_cast<EnumType>(7);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DoorLockSetPinOrIdStatus val)
{
    using EnumType = DoorLock::DoorLockSetPinOrIdStatus;
    switch (val)
    {
    case EnumType::kSuccess:
    case EnumType::kGeneralFailure:
    case EnumType::kMemoryFull:
    case EnumType::kDuplicateCodeError:
        return val;
    default:
        return static_cast<EnumType>(4);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DoorLockUserStatus val)
{
    using EnumType = DoorLock::DoorLockUserStatus;
    switch (val)
    {
    case EnumType::kAvailable:
    case EnumType::kOccupiedEnabled:
    case EnumType::kOccupiedDisabled:
    case EnumType::kNotSupported:
        return val;
    default:
        return static_cast<EnumType>(2);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DoorLockUserType val)
{
    using EnumType = DoorLock::DoorLockUserType;
    switch (val)
    {
    case EnumType::kUnrestricted:
    case EnumType::kYearDayScheduleUser:
    case EnumType::kWeekDayScheduleUser:
    case EnumType::kMasterUser:
    case EnumType::kNonAccessUser:
    case EnumType::kNotSupported:
        return val;
    default:
        return static_cast<EnumType>(5);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DoorStateEnum val)
{
    using EnumType = DoorLock::DoorStateEnum;
    switch (val)
    {
    case EnumType::kDoorOpen:
    case EnumType::kDoorClosed:
    case EnumType::kDoorJammed:
    case EnumType::kDoorForcedOpen:
    case EnumType::kDoorUnspecifiedError:
    case EnumType::kDoorAjar:
        return val;
    default:
        return static_cast<EnumType>(6);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::LockDataTypeEnum val)
{
    using EnumType = DoorLock::LockDataTypeEnum;
    switch (val)
    {
    case EnumType::kUnspecified:
    case EnumType::kProgrammingCode:
    case EnumType::kUserIndex:
    case EnumType::kWeekDaySchedule:
    case EnumType::kYearDaySchedule:
    case EnumType::kHolidaySchedule:
    case EnumType::kPin:
    case EnumType::kRfid:
    case EnumType::kFingerprint:
        return val;
    default:
        return static_cast<EnumType>(9);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::LockOperationTypeEnum val)
{
    using EnumType = DoorLock::LockOperationTypeEnum;
    switch (val)
    {
    case EnumType::kLock:
    case EnumType::kUnlock:
    case EnumType::kNonAccessUserEvent:
    case EnumType::kForcedUserEvent:
        return val;
    default:
        return static_cast<EnumType>(4);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::OperatingModeEnum val)
{
    using EnumType = DoorLock::OperatingModeEnum;
    switch (val)
    {
    case EnumType::kNormal:
    case EnumType::kVacation:
    case EnumType::kPrivacy:
    case EnumType::kNoRemoteLockUnlock:
    case EnumType::kPassage:
        return val;
    default:
        return static_cast<EnumType>(5);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::OperationErrorEnum val)
{
    using EnumType = DoorLock::OperationErrorEnum;
    switch (val)
    {
    case EnumType::kUnspecified:
    case EnumType::kInvalidCredential:
    case EnumType::kDisabledUserDenied:
    case EnumType::kRestricted:
    case EnumType::kInsufficientBattery:
        return val;
    default:
        return static_cast<EnumType>(5);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::OperationSourceEnum val)
{
    using EnumType = DoorLock::OperationSourceEnum;
    switch (val)
    {
    case EnumType::kUnspecified:
    case EnumType::kManual:
    case EnumType::kProprietaryRemote:
    case EnumType::kKeypad:
    case EnumType::kAuto:
    case EnumType::kButton:
    case EnumType::kSchedule:
    case EnumType::kRemote:
    case EnumType::kRfid:
    case EnumType::kBiometric:
        return val;
    default:
        return static_cast<EnumType>(10);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::UserStatusEnum val)
{
    using EnumType = DoorLock::UserStatusEnum;
    switch (val)
    {
    case EnumType::kAvailable:
    case EnumType::kOccupiedEnabled:
    case EnumType::kOccupiedDisabled:
        return val;
    default:
        return static_cast<EnumType>(2);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::UserTypeEnum val)
{
    using EnumType = DoorLock::UserTypeEnum;
    switch (val)
    {
    case EnumType::kUnrestrictedUser:
    case EnumType::kYearDayScheduleUser:
    case EnumType::kWeekDayScheduleUser:
    case EnumType::kProgrammingUser:
    case EnumType::kNonAccessUser:
    case EnumType::kForcedUser:
    case EnumType::kDisposableUser:
    case EnumType::kExpiringUser:
    case EnumType::kScheduleRestrictedUser:
    case EnumType::kRemoteOnlyUser:
        return val;
    default:
        return static_cast<EnumType>(10);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(WindowCovering::EndProductType val)
{
    using EnumType = WindowCovering::EndProductType;
    switch (val)
    {
    case EnumType::kRollerShade:
    case EnumType::kRomanShade:
    case EnumType::kBalloonShade:
    case EnumType::kWovenWood:
    case EnumType::kPleatedShade:
    case EnumType::kCellularShade:
    case EnumType::kLayeredShade:
    case EnumType::kLayeredShade2D:
    case EnumType::kSheerShade:
    case EnumType::kTiltOnlyInteriorBlind:
    case EnumType::kInteriorBlind:
    case EnumType::kVerticalBlindStripCurtain:
    case EnumType::kInteriorVenetianBlind:
    case EnumType::kExteriorVenetianBlind:
    case EnumType::kLateralLeftCurtain:
    case EnumType::kLateralRightCurtain:
    case EnumType::kCentralCurtain:
    case EnumType::kRollerShutter:
    case EnumType::kExteriorVerticalScreen:
    case EnumType::kAwningTerracePatio:
    case EnumType::kAwningVerticalScreen:
    case EnumType::kTiltOnlyPergola:
    case EnumType::kSwingingShutter:
    case EnumType::kSlidingShutter:
    case EnumType::kUnknown:
        return val;
    default:
        return static_cast<EnumType>(24);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(WindowCovering::Type val)
{
    using EnumType = WindowCovering::Type;
    switch (val)
    {
    case EnumType::kRollerShade:
    case EnumType::kRollerShade2Motor:
    case EnumType::kRollerShadeExterior:
    case EnumType::kRollerShadeExterior2Motor:
    case EnumType::kDrapery:
    case EnumType::kAwning:
    case EnumType::kShutter:
    case EnumType::kTiltBlindTiltOnly:
    case EnumType::kTiltBlindLiftAndTilt:
    case EnumType::kProjectorScreen:
    case EnumType::kUnknown:
        return val;
    default:
        return static_cast<EnumType>(10);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(PumpConfigurationAndControl::PumpControlMode val)
{
    using EnumType = PumpConfigurationAndControl::PumpControlMode;
    switch (val)
    {
    case EnumType::kConstantSpeed:
    case EnumType::kConstantPressure:
    case EnumType::kProportionalPressure:
    case EnumType::kConstantFlow:
    case EnumType::kConstantTemperature:
    case EnumType::kAutomatic:
        return val;
    default:
        return static_cast<EnumType>(4);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(PumpConfigurationAndControl::PumpOperationMode val)
{
    using EnumType = PumpConfigurationAndControl::PumpOperationMode;
    switch (val)
    {
    case EnumType::kNormal:
    case EnumType::kMinimum:
    case EnumType::kMaximum:
    case EnumType::kLocal:
        return val;
    default:
        return static_cast<EnumType>(4);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(Thermostat::SetpointAdjustMode val)
{
    using EnumType = Thermostat::SetpointAdjustMode;
    switch (val)
    {
    case EnumType::kHeat:
    case EnumType::kCool:
    case EnumType::kBoth:
        return val;
    default:
        return static_cast<EnumType>(3);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(Thermostat::ThermostatControlSequence val)
{
    using EnumType = Thermostat::ThermostatControlSequence;
    switch (val)
    {
    case EnumType::kCoolingOnly:
    case EnumType::kCoolingWithReheat:
    case EnumType::kHeatingOnly:
    case EnumType::kHeatingWithReheat:
    case EnumType::kCoolingAndHeating:
    case EnumType::kCoolingAndHeatingWithReheat:
        return val;
    default:
        return static_cast<EnumType>(6);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(Thermostat::ThermostatRunningMode val)
{
    using EnumType = Thermostat::ThermostatRunningMode;
    switch (val)
    {
    case EnumType::kOff:
    case EnumType::kCool:
    case EnumType::kHeat:
        return val;
    default:
        return static_cast<EnumType>(1);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(Thermostat::ThermostatSystemMode val)
{
    using EnumType = Thermostat::ThermostatSystemMode;
    switch (val)
    {
    case EnumType::kOff:
    case EnumType::kAuto:
    case EnumType::kCool:
    case EnumType::kHeat:
    case EnumType::kEmergencyHeat:
    case EnumType::kPrecooling:
    case EnumType::kFanOnly:
    case EnumType::kDry:
    case EnumType::kSleep:
        return val;
    default:
        return static_cast<EnumType>(2);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(FanControl::FanModeSequenceType val)
{
    using EnumType = FanControl::FanModeSequenceType;
    switch (val)
    {
    case EnumType::kOffLowMedHigh:
    case EnumType::kOffLowHigh:
    case EnumType::kOffLowMedHighAuto:
    case EnumType::kOffLowHighAuto:
    case EnumType::kOffOnAuto:
    case EnumType::kOffOn:
        return val;
    default:
        return static_cast<EnumType>(6);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(FanControl::FanModeType val)
{
    using EnumType = FanControl::FanModeType;
    switch (val)
    {
    case EnumType::kOff:
    case EnumType::kLow:
    case EnumType::kMedium:
    case EnumType::kHigh:
    case EnumType::kOn:
    case EnumType::kAuto:
    case EnumType::kSmart:
        return val;
    default:
        return static_cast<EnumType>(7);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(ColorControl::ColorLoopAction val)
{
    using EnumType = ColorControl::ColorLoopAction;
    switch (val)
    {
// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EnumType::kDeactivate:
    case EnumType::kActivateFromColorLoopStartEnhancedHue:
    case EnumType::kActivateFromEnhancedCurrentHue:
#else  // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EMBER_ZCL_COLOR_LOOP_ACTION_DEACTIVATE:
    case EMBER_ZCL_COLOR_LOOP_ACTION_ACTIVATE_FROM_COLOR_LOOP_START_ENHANCED_HUE:
    case EMBER_ZCL_COLOR_LOOP_ACTION_ACTIVATE_FROM_ENHANCED_CURRENT_HUE:
#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
        return val;
    default:
        return static_cast<EnumType>(3);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(ColorControl::ColorLoopDirection val)
{
    using EnumType = ColorControl::ColorLoopDirection;
    switch (val)
    {
// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EnumType::kDecrementHue:
    case EnumType::kIncrementHue:
#else  // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EMBER_ZCL_COLOR_LOOP_DIRECTION_DECREMENT_HUE:
    case EMBER_ZCL_COLOR_LOOP_DIRECTION_INCREMENT_HUE:
#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
        return val;
    default:
        return static_cast<EnumType>(2);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(ColorControl::ColorMode val)
{
    using EnumType = ColorControl::ColorMode;
    switch (val)
    {
// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EnumType::kCurrentHueAndCurrentSaturation:
    case EnumType::kCurrentXAndCurrentY:
    case EnumType::kColorTemperature:
#else  // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EMBER_ZCL_COLOR_MODE_CURRENT_HUE_AND_CURRENT_SATURATION:
    case EMBER_ZCL_COLOR_MODE_CURRENT_X_AND_CURRENT_Y:
    case EMBER_ZCL_COLOR_MODE_COLOR_TEMPERATURE:
#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
        return val;
    default:
        return static_cast<EnumType>(3);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(ColorControl::HueDirection val)
{
    using EnumType = ColorControl::HueDirection;
    switch (val)
    {
// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EnumType::kShortestDistance:
    case EnumType::kLongestDistance:
    case EnumType::kUp:
    case EnumType::kDown:
#else  // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EMBER_ZCL_HUE_DIRECTION_SHORTEST_DISTANCE:
    case EMBER_ZCL_HUE_DIRECTION_LONGEST_DISTANCE:
    case EMBER_ZCL_HUE_DIRECTION_UP:
    case EMBER_ZCL_HUE_DIRECTION_DOWN:
#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
        return val;
    default:
        return static_cast<EnumType>(4);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(ColorControl::HueMoveMode val)
{
    using EnumType = ColorControl::HueMoveMode;
    switch (val)
    {
// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EnumType::kStop:
    case EnumType::kUp:
    case EnumType::kDown:
#else  // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EMBER_ZCL_HUE_MOVE_MODE_STOP:
    case EMBER_ZCL_HUE_MOVE_MODE_UP:
    case EMBER_ZCL_HUE_MOVE_MODE_DOWN:
#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
        return val;
    default:
        return static_cast<EnumType>(2);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(ColorControl::HueStepMode val)
{
    using EnumType = ColorControl::HueStepMode;
    switch (val)
    {
// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EnumType::kUp:
    case EnumType::kDown:
#else  // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EMBER_ZCL_HUE_STEP_MODE_UP:
    case EMBER_ZCL_HUE_STEP_MODE_DOWN:
#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
        return val;
    default:
        return static_cast<EnumType>(0);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(ColorControl::SaturationMoveMode val)
{
    using EnumType = ColorControl::SaturationMoveMode;
    switch (val)
    {
// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EnumType::kStop:
    case EnumType::kUp:
    case EnumType::kDown:
#else  // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EMBER_ZCL_SATURATION_MOVE_MODE_STOP:
    case EMBER_ZCL_SATURATION_MOVE_MODE_UP:
    case EMBER_ZCL_SATURATION_MOVE_MODE_DOWN:
#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
        return val;
    default:
        return static_cast<EnumType>(2);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(ColorControl::SaturationStepMode val)
{
    using EnumType = ColorControl::SaturationStepMode;
    switch (val)
    {
// Need to convert consumers to using the new enum classes, so we
// don't just have casts all over.
#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EnumType::kUp:
    case EnumType::kDown:
#else  // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
    case EMBER_ZCL_SATURATION_STEP_MODE_UP:
    case EMBER_ZCL_SATURATION_STEP_MODE_DOWN:
#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM
        return val;
    default:
        return static_cast<EnumType>(0);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(IlluminanceMeasurement::LightSensorType val)
{
    using EnumType = IlluminanceMeasurement::LightSensorType;
    switch (val)
    {
    case EnumType::kPhotodiode:
    case EnumType::kCmos:
        return val;
    default:
        return static_cast<EnumType>(2);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(Channel::ChannelStatusEnum val)
{
    using EnumType = Channel::ChannelStatusEnum;
    switch (val)
    {
    case EnumType::kSuccess:
    case EnumType::kMultipleMatches:
    case EnumType::kNoMatches:
        return val;
    default:
        return static_cast<EnumType>(3);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(Channel::LineupInfoTypeEnum val)
{
    using EnumType = Channel::LineupInfoTypeEnum;
    switch (val)
    {
    case EnumType::kMso:
        return val;
    default:
        return static_cast<EnumType>(1);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(TargetNavigator::TargetNavigatorStatusEnum val)
{
    using EnumType = TargetNavigator::TargetNavigatorStatusEnum;
    switch (val)
    {
    case EnumType::kSuccess:
    case EnumType::kTargetNotFound:
    case EnumType::kNotAllowed:
        return val;
    default:
        return static_cast<EnumType>(3);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(MediaPlayback::MediaPlaybackStatusEnum val)
{
    using EnumType = MediaPlayback::MediaPlaybackStatusEnum;
    switch (val)
    {
    case EnumType::kSuccess:
    case EnumType::kInvalidStateForCommand:
    case EnumType::kNotAllowed:
    case EnumType::kNotActive:
    case EnumType::kSpeedOutOfRange:
    case EnumType::kSeekOutOfRange:
        return val;
    default:
        return static_cast<EnumType>(6);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(MediaPlayback::PlaybackStateEnum val)
{
    using EnumType = MediaPlayback::PlaybackStateEnum;
    switch (val)
    {
    case EnumType::kPlaying:
    case EnumType::kPaused:
    case EnumType::kNotPlaying:
    case EnumType::kBuffering:
        return val;
    default:
        return static_cast<EnumType>(4);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(MediaInput::InputTypeEnum val)
{
    using EnumType = MediaInput::InputTypeEnum;
    switch (val)
    {
    case EnumType::kInternal:
    case EnumType::kAux:
    case EnumType::kCoax:
    case EnumType::kComposite:
    case EnumType::kHdmi:
    case EnumType::kInput:
    case EnumType::kLine:
    case EnumType::kOptical:
    case EnumType::kVideo:
    case EnumType::kScart:
    case EnumType::kUsb:
    case EnumType::kOther:
        return val;
    default:
        return static_cast<EnumType>(12);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(KeypadInput::CecKeyCode val)
{
    using EnumType = KeypadInput::CecKeyCode;
    switch (val)
    {
    case EnumType::kSelect:
    case EnumType::kUp:
    case EnumType::kDown:
    case EnumType::kLeft:
    case EnumType::kRight:
    case EnumType::kRightUp:
    case EnumType::kRightDown:
    case EnumType::kLeftUp:
    case EnumType::kLeftDown:
    case EnumType::kRootMenu:
    case EnumType::kSetupMenu:
    case EnumType::kContentsMenu:
    case EnumType::kFavoriteMenu:
    case EnumType::kExit:
    case EnumType::kMediaTopMenu:
    case EnumType::kMediaContextSensitiveMenu:
    case EnumType::kNumberEntryMode:
    case EnumType::kNumber11:
    case EnumType::kNumber12:
    case EnumType::kNumber0OrNumber10:
    case EnumType::kNumbers1:
    case EnumType::kNumbers2:
    case EnumType::kNumbers3:
    case EnumType::kNumbers4:
    case EnumType::kNumbers5:
    case EnumType::kNumbers6:
    case EnumType::kNumbers7:
    case EnumType::kNumbers8:
    case EnumType::kNumbers9:
    case EnumType::kDot:
    case EnumType::kEnter:
    case EnumType::kClear:
    case EnumType::kNextFavorite:
    case EnumType::kChannelUp:
    case EnumType::kChannelDown:
    case EnumType::kPreviousChannel:
    case EnumType::kSoundSelect:
    case EnumType::kInputSelect:
    case EnumType::kDisplayInformation:
    case EnumType::kHelp:
    case EnumType::kPageUp:
    case EnumType::kPageDown:
    case EnumType::kPower:
    case EnumType::kVolumeUp:
    case EnumType::kVolumeDown:
    case EnumType::kMute:
    case EnumType::kPlay:
    case EnumType::kStop:
    case EnumType::kPause:
    case EnumType::kRecord:
    case EnumType::kRewind:
    case EnumType::kFastForward:
    case EnumType::kEject:
    case EnumType::kForward:
    case EnumType::kBackward:
    case EnumType::kStopRecord:
    case EnumType::kPauseRecord:
    case EnumType::kReserved:
    case EnumType::kAngle:
    case EnumType::kSubPicture:
    case EnumType::kVideoOnDemand:
    case EnumType::kElectronicProgramGuide:
    case EnumType::kTimerProgramming:
    case EnumType::kInitialConfiguration:
    case EnumType::kSelectBroadcastType:
    case EnumType::kSelectSoundPresentation:
    case EnumType::kPlayFunction:
    case EnumType::kPausePlayFunction:
    case EnumType::kRecordFunction:
    case EnumType::kPauseRecordFunction:
    case EnumType::kStopFunction:
    case EnumType::kMuteFunction:
    case EnumType::kRestoreVolumeFunction:
    case EnumType::kTuneFunction:
    case EnumType::kSelectMediaFunction:
    case EnumType::kSelectAvInputFunction:
    case EnumType::kSelectAudioInputFunction:
    case EnumType::kPowerToggleFunction:
    case EnumType::kPowerOffFunction:
    case EnumType::kPowerOnFunction:
    case EnumType::kF1Blue:
    case EnumType::kF2Red:
    case EnumType::kF3Green:
    case EnumType::kF4Yellow:
    case EnumType::kF5:
    case EnumType::kData:
        return val;
    default:
        return static_cast<EnumType>(14);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(KeypadInput::KeypadInputStatusEnum val)
{
    using EnumType = KeypadInput::KeypadInputStatusEnum;
    switch (val)
    {
    case EnumType::kSuccess:
    case EnumType::kUnsupportedKey:
    case EnumType::kInvalidKeyInCurrentState:
        return val;
    default:
        return static_cast<EnumType>(3);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(ContentLauncher::ContentLaunchStatusEnum val)
{
    using EnumType = ContentLauncher::ContentLaunchStatusEnum;
    switch (val)
    {
    case EnumType::kSuccess:
    case EnumType::kUrlNotAvailable:
    case EnumType::kAuthFailed:
        return val;
    default:
        return static_cast<EnumType>(3);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(ContentLauncher::MetricTypeEnum val)
{
    using EnumType = ContentLauncher::MetricTypeEnum;
    switch (val)
    {
    case EnumType::kPixels:
    case EnumType::kPercentage:
        return val;
    default:
        return static_cast<EnumType>(2);
    }
}
static auto __attribute__((unused)) EnsureKnownEnumValue(ContentLauncher::ParameterEnum val)
{
    using EnumType = ContentLauncher::ParameterEnum;
    switch (val)
    {
    case EnumType::kActor:
    case EnumType::kChannel:
    case EnumType::kCharacter:
    case EnumType::kDirector:
    case EnumType::kEvent:
    case EnumType::kFranchise:
    case EnumType::kGenre:
    case EnumType::kLeague:
    case EnumType::kPopularity:
    case EnumType::kProvider:
    case EnumType::kSport:
    case EnumType::kSportsTeam:
    case EnumType::kType:
    case EnumType::kVideo:
        return val;
    default:
        return static_cast<EnumType>(14);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(AudioOutput::OutputTypeEnum val)
{
    using EnumType = AudioOutput::OutputTypeEnum;
    switch (val)
    {
    case EnumType::kHdmi:
    case EnumType::kBt:
    case EnumType::kOptical:
    case EnumType::kHeadphone:
    case EnumType::kInternal:
    case EnumType::kOther:
        return val;
    default:
        return static_cast<EnumType>(6);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(ApplicationLauncher::ApplicationLauncherStatusEnum val)
{
    using EnumType = ApplicationLauncher::ApplicationLauncherStatusEnum;
    switch (val)
    {
    case EnumType::kSuccess:
    case EnumType::kAppNotAvailable:
    case EnumType::kSystemBusy:
        return val;
    default:
        return static_cast<EnumType>(3);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(ApplicationBasic::ApplicationStatusEnum val)
{
    using EnumType = ApplicationBasic::ApplicationStatusEnum;
    switch (val)
    {
    case EnumType::kStopped:
    case EnumType::kActiveVisibleFocus:
    case EnumType::kActiveHidden:
    case EnumType::kActiveVisibleNotFocus:
        return val;
    default:
        return static_cast<EnumType>(4);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(UnitTesting::SimpleEnum val)
{
    using EnumType = UnitTesting::SimpleEnum;
    switch (val)
    {
    case EnumType::kUnspecified:
    case EnumType::kValueA:
    case EnumType::kValueB:
    case EnumType::kValueC:
        return val;
    default:
        return static_cast<EnumType>(4);
    }
}

static auto __attribute__((unused)) EnsureKnownEnumValue(FaultInjection::FaultType val)
{
    using EnumType = FaultInjection::FaultType;
    switch (val)
    {
    case EnumType::kUnspecified:
    case EnumType::kSystemFault:
    case EnumType::kInetFault:
    case EnumType::kChipFault:
    case EnumType::kCertFault:
        return val;
    default:
        return static_cast<EnumType>(5);
    }
}

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