/*
 *
 *    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 <cstdint>
#include <string>
#include <type_traits>

#include <app-common/zap-generated/cluster-objects.h>
#include <app-common/zap-generated/ids/Clusters.h>
#include <app-common/zap-generated/ids/Commands.h>
#include <commands/clusters/ClusterCommand.h>
#include <commands/clusters/ComplexArgument.h>
#include <commands/clusters/ReportCommand.h>
#include <commands/clusters/WriteAttributeCommand.h>
#include <commands/common/Commands.h>

/*----------------------------------------------------------------------------*\
| Cluster Name                                                        |   ID   |
|---------------------------------------------------------------------+--------|
| Identify                                                            | 0x0003 |
| Groups                                                              | 0x0004 |
| OnOff                                                               | 0x0006 |
| OnOffSwitchConfiguration                                            | 0x0007 |
| LevelControl                                                        | 0x0008 |
| BinaryInputBasic                                                    | 0x000F |
| PulseWidthModulation                                                | 0x001C |
| Descriptor                                                          | 0x001D |
| Binding                                                             | 0x001E |
| AccessControl                                                       | 0x001F |
| Actions                                                             | 0x0025 |
| BasicInformation                                                    | 0x0028 |
| OtaSoftwareUpdateProvider                                           | 0x0029 |
| OtaSoftwareUpdateRequestor                                          | 0x002A |
| LocalizationConfiguration                                           | 0x002B |
| TimeFormatLocalization                                              | 0x002C |
| UnitLocalization                                                    | 0x002D |
| PowerSourceConfiguration                                            | 0x002E |
| PowerSource                                                         | 0x002F |
| GeneralCommissioning                                                | 0x0030 |
| NetworkCommissioning                                                | 0x0031 |
| DiagnosticLogs                                                      | 0x0032 |
| GeneralDiagnostics                                                  | 0x0033 |
| SoftwareDiagnostics                                                 | 0x0034 |
| ThreadNetworkDiagnostics                                            | 0x0035 |
| WiFiNetworkDiagnostics                                              | 0x0036 |
| EthernetNetworkDiagnostics                                          | 0x0037 |
| TimeSynchronization                                                 | 0x0038 |
| BridgedDeviceBasicInformation                                       | 0x0039 |
| Switch                                                              | 0x003B |
| AdministratorCommissioning                                          | 0x003C |
| OperationalCredentials                                              | 0x003E |
| GroupKeyManagement                                                  | 0x003F |
| FixedLabel                                                          | 0x0040 |
| UserLabel                                                           | 0x0041 |
| ProxyConfiguration                                                  | 0x0042 |
| ProxyDiscovery                                                      | 0x0043 |
| ProxyValid                                                          | 0x0044 |
| BooleanState                                                        | 0x0045 |
| IcdManagement                                                       | 0x0046 |
| Timer                                                               | 0x0047 |
| OvenCavityOperationalState                                          | 0x0048 |
| OvenMode                                                            | 0x0049 |
| LaundryDryerControls                                                | 0x004A |
| ModeSelect                                                          | 0x0050 |
| LaundryWasherMode                                                   | 0x0051 |
| RefrigeratorAndTemperatureControlledCabinetMode                     | 0x0052 |
| LaundryWasherControls                                               | 0x0053 |
| RvcRunMode                                                          | 0x0054 |
| RvcCleanMode                                                        | 0x0055 |
| TemperatureControl                                                  | 0x0056 |
| RefrigeratorAlarm                                                   | 0x0057 |
| DishwasherMode                                                      | 0x0059 |
| AirQuality                                                          | 0x005B |
| SmokeCoAlarm                                                        | 0x005C |
| DishwasherAlarm                                                     | 0x005D |
| MicrowaveOvenMode                                                   | 0x005E |
| MicrowaveOvenControl                                                | 0x005F |
| OperationalState                                                    | 0x0060 |
| RvcOperationalState                                                 | 0x0061 |
| ScenesManagement                                                    | 0x0062 |
| HepaFilterMonitoring                                                | 0x0071 |
| ActivatedCarbonFilterMonitoring                                     | 0x0072 |
| BooleanStateConfiguration                                           | 0x0080 |
| ValveConfigurationAndControl                                        | 0x0081 |
| ElectricalPowerMeasurement                                          | 0x0090 |
| ElectricalEnergyMeasurement                                         | 0x0091 |
| DemandResponseLoadControl                                           | 0x0096 |
| Messages                                                            | 0x0097 |
| DeviceEnergyManagement                                              | 0x0098 |
| EnergyEvse                                                          | 0x0099 |
| EnergyPreference                                                    | 0x009B |
| PowerTopology                                                       | 0x009C |
| EnergyEvseMode                                                      | 0x009D |
| DeviceEnergyManagementMode                                          | 0x009F |
| DoorLock                                                            | 0x0101 |
| WindowCovering                                                      | 0x0102 |
| BarrierControl                                                      | 0x0103 |
| PumpConfigurationAndControl                                         | 0x0200 |
| Thermostat                                                          | 0x0201 |
| FanControl                                                          | 0x0202 |
| ThermostatUserInterfaceConfiguration                                | 0x0204 |
| ColorControl                                                        | 0x0300 |
| BallastConfiguration                                                | 0x0301 |
| IlluminanceMeasurement                                              | 0x0400 |
| TemperatureMeasurement                                              | 0x0402 |
| PressureMeasurement                                                 | 0x0403 |
| FlowMeasurement                                                     | 0x0404 |
| RelativeHumidityMeasurement                                         | 0x0405 |
| OccupancySensing                                                    | 0x0406 |
| CarbonMonoxideConcentrationMeasurement                              | 0x040C |
| CarbonDioxideConcentrationMeasurement                               | 0x040D |
| NitrogenDioxideConcentrationMeasurement                             | 0x0413 |
| OzoneConcentrationMeasurement                                       | 0x0415 |
| Pm25ConcentrationMeasurement                                        | 0x042A |
| FormaldehydeConcentrationMeasurement                                | 0x042B |
| Pm1ConcentrationMeasurement                                         | 0x042C |
| Pm10ConcentrationMeasurement                                        | 0x042D |
| TotalVolatileOrganicCompoundsConcentrationMeasurement               | 0x042E |
| RadonConcentrationMeasurement                                       | 0x042F |
| WakeOnLan                                                           | 0x0503 |
| Channel                                                             | 0x0504 |
| TargetNavigator                                                     | 0x0505 |
| MediaPlayback                                                       | 0x0506 |
| MediaInput                                                          | 0x0507 |
| LowPower                                                            | 0x0508 |
| KeypadInput                                                         | 0x0509 |
| ContentLauncher                                                     | 0x050A |
| AudioOutput                                                         | 0x050B |
| ApplicationLauncher                                                 | 0x050C |
| ApplicationBasic                                                    | 0x050D |
| AccountLogin                                                        | 0x050E |
| ContentControl                                                      | 0x050F |
| ContentAppObserver                                                  | 0x0510 |
| ElectricalMeasurement                                               | 0x0B04 |
| UnitTesting                                                         | 0xFFF1FC05|
| FaultInjection                                                      | 0xFFF1FC06|
| SampleMei                                                           | 0xFFF1FC20|
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster Identify                                                    | 0x0003 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * Identify                                                          |   0x00 |
| * TriggerEffect                                                     |   0x40 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * IdentifyTime                                                      | 0x0000 |
| * IdentifyType                                                      | 0x0001 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command Identify
 */
class IdentifyIdentify : public ClusterCommand
{
public:
    IdentifyIdentify(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("identify", credsIssuerConfig)
    {
        AddArgument("IdentifyTime", 0, UINT16_MAX, &mRequest.identifyTime);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Identify::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Identify::Commands::Identify::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Identify::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Identify::Commands::Identify::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Identify::Commands::Identify::Type mRequest;
};

/*
 * Command TriggerEffect
 */
class IdentifyTriggerEffect : public ClusterCommand
{
public:
    IdentifyTriggerEffect(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("trigger-effect", credsIssuerConfig)
    {
        AddArgument("EffectIdentifier", 0, UINT8_MAX, &mRequest.effectIdentifier);
        AddArgument("EffectVariant", 0, UINT8_MAX, &mRequest.effectVariant);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Identify::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Identify::Commands::TriggerEffect::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Identify::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Identify::Commands::TriggerEffect::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Identify::Commands::TriggerEffect::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster Groups                                                      | 0x0004 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * AddGroup                                                          |   0x00 |
| * ViewGroup                                                         |   0x01 |
| * GetGroupMembership                                                |   0x02 |
| * RemoveGroup                                                       |   0x03 |
| * RemoveAllGroups                                                   |   0x04 |
| * AddGroupIfIdentifying                                             |   0x05 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * NameSupport                                                       | 0x0000 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command AddGroup
 */
class GroupsAddGroup : public ClusterCommand
{
public:
    GroupsAddGroup(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("add-group", credsIssuerConfig)
    {
        AddArgument("GroupID", 0, UINT16_MAX, &mRequest.groupID);
        AddArgument("GroupName", &mRequest.groupName);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Groups::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Groups::Commands::AddGroup::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Groups::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Groups::Commands::AddGroup::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Groups::Commands::AddGroup::Type mRequest;
};

/*
 * Command ViewGroup
 */
class GroupsViewGroup : public ClusterCommand
{
public:
    GroupsViewGroup(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("view-group", credsIssuerConfig)
    {
        AddArgument("GroupID", 0, UINT16_MAX, &mRequest.groupID);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Groups::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Groups::Commands::ViewGroup::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Groups::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Groups::Commands::ViewGroup::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Groups::Commands::ViewGroup::Type mRequest;
};

/*
 * Command GetGroupMembership
 */
class GroupsGetGroupMembership : public ClusterCommand
{
public:
    GroupsGetGroupMembership(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("get-group-membership", credsIssuerConfig), mComplex_GroupList(&mRequest.groupList)
    {
        AddArgument("GroupList", &mComplex_GroupList);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Groups::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Groups::Commands::GetGroupMembership::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Groups::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Groups::Commands::GetGroupMembership::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Groups::Commands::GetGroupMembership::Type mRequest;
    TypedComplexArgument<chip::app::DataModel::List<const chip::GroupId>> mComplex_GroupList;
};

/*
 * Command RemoveGroup
 */
class GroupsRemoveGroup : public ClusterCommand
{
public:
    GroupsRemoveGroup(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("remove-group", credsIssuerConfig)
    {
        AddArgument("GroupID", 0, UINT16_MAX, &mRequest.groupID);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Groups::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Groups::Commands::RemoveGroup::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Groups::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Groups::Commands::RemoveGroup::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Groups::Commands::RemoveGroup::Type mRequest;
};

/*
 * Command RemoveAllGroups
 */
class GroupsRemoveAllGroups : public ClusterCommand
{
public:
    GroupsRemoveAllGroups(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("remove-all-groups", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Groups::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Groups::Commands::RemoveAllGroups::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Groups::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Groups::Commands::RemoveAllGroups::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Groups::Commands::RemoveAllGroups::Type mRequest;
};

/*
 * Command AddGroupIfIdentifying
 */
class GroupsAddGroupIfIdentifying : public ClusterCommand
{
public:
    GroupsAddGroupIfIdentifying(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("add-group-if-identifying", credsIssuerConfig)
    {
        AddArgument("GroupID", 0, UINT16_MAX, &mRequest.groupID);
        AddArgument("GroupName", &mRequest.groupName);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Groups::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Groups::Commands::AddGroupIfIdentifying::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Groups::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Groups::Commands::AddGroupIfIdentifying::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Groups::Commands::AddGroupIfIdentifying::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster OnOff                                                       | 0x0006 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * Off                                                               |   0x00 |
| * On                                                                |   0x01 |
| * Toggle                                                            |   0x02 |
| * OffWithEffect                                                     |   0x40 |
| * OnWithRecallGlobalScene                                           |   0x41 |
| * OnWithTimedOff                                                    |   0x42 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * OnOff                                                             | 0x0000 |
| * GlobalSceneControl                                                | 0x4000 |
| * OnTime                                                            | 0x4001 |
| * OffWaitTime                                                       | 0x4002 |
| * StartUpOnOff                                                      | 0x4003 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command Off
 */
class OnOffOff : public ClusterCommand
{
public:
    OnOffOff(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("off", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OnOff::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OnOff::Commands::Off::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OnOff::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OnOff::Commands::Off::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::OnOff::Commands::Off::Type mRequest;
};

/*
 * Command On
 */
class OnOffOn : public ClusterCommand
{
public:
    OnOffOn(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("on", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OnOff::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OnOff::Commands::On::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OnOff::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OnOff::Commands::On::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::OnOff::Commands::On::Type mRequest;
};

/*
 * Command Toggle
 */
class OnOffToggle : public ClusterCommand
{
public:
    OnOffToggle(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("toggle", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OnOff::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OnOff::Commands::Toggle::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OnOff::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OnOff::Commands::Toggle::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::OnOff::Commands::Toggle::Type mRequest;
};

/*
 * Command OffWithEffect
 */
class OnOffOffWithEffect : public ClusterCommand
{
public:
    OnOffOffWithEffect(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("off-with-effect", credsIssuerConfig)
    {
        AddArgument("EffectIdentifier", 0, UINT8_MAX, &mRequest.effectIdentifier);
        AddArgument("EffectVariant", 0, UINT8_MAX, &mRequest.effectVariant);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OnOff::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OnOff::Commands::OffWithEffect::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OnOff::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OnOff::Commands::OffWithEffect::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::OnOff::Commands::OffWithEffect::Type mRequest;
};

/*
 * Command OnWithRecallGlobalScene
 */
class OnOffOnWithRecallGlobalScene : public ClusterCommand
{
public:
    OnOffOnWithRecallGlobalScene(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("on-with-recall-global-scene", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OnOff::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OnOff::Commands::OnWithRecallGlobalScene::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OnOff::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OnOff::Commands::OnWithRecallGlobalScene::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::OnOff::Commands::OnWithRecallGlobalScene::Type mRequest;
};

/*
 * Command OnWithTimedOff
 */
class OnOffOnWithTimedOff : public ClusterCommand
{
public:
    OnOffOnWithTimedOff(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("on-with-timed-off", credsIssuerConfig)
    {
        AddArgument("OnOffControl", 0, UINT8_MAX, &mRequest.onOffControl);
        AddArgument("OnTime", 0, UINT16_MAX, &mRequest.onTime);
        AddArgument("OffWaitTime", 0, UINT16_MAX, &mRequest.offWaitTime);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OnOff::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OnOff::Commands::OnWithTimedOff::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OnOff::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OnOff::Commands::OnWithTimedOff::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::OnOff::Commands::OnWithTimedOff::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster OnOffSwitchConfiguration                                    | 0x0007 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * SwitchType                                                        | 0x0000 |
| * SwitchActions                                                     | 0x0010 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster LevelControl                                                | 0x0008 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * MoveToLevel                                                       |   0x00 |
| * Move                                                              |   0x01 |
| * Step                                                              |   0x02 |
| * Stop                                                              |   0x03 |
| * MoveToLevelWithOnOff                                              |   0x04 |
| * MoveWithOnOff                                                     |   0x05 |
| * StepWithOnOff                                                     |   0x06 |
| * StopWithOnOff                                                     |   0x07 |
| * MoveToClosestFrequency                                            |   0x08 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * CurrentLevel                                                      | 0x0000 |
| * RemainingTime                                                     | 0x0001 |
| * MinLevel                                                          | 0x0002 |
| * MaxLevel                                                          | 0x0003 |
| * CurrentFrequency                                                  | 0x0004 |
| * MinFrequency                                                      | 0x0005 |
| * MaxFrequency                                                      | 0x0006 |
| * Options                                                           | 0x000F |
| * OnOffTransitionTime                                               | 0x0010 |
| * OnLevel                                                           | 0x0011 |
| * OnTransitionTime                                                  | 0x0012 |
| * OffTransitionTime                                                 | 0x0013 |
| * DefaultMoveRate                                                   | 0x0014 |
| * StartUpCurrentLevel                                               | 0x4000 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command MoveToLevel
 */
class LevelControlMoveToLevel : public ClusterCommand
{
public:
    LevelControlMoveToLevel(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("move-to-level", credsIssuerConfig)
    {
        AddArgument("Level", 0, UINT8_MAX, &mRequest.level);
        AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::LevelControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::LevelControl::Commands::MoveToLevel::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::LevelControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::LevelControl::Commands::MoveToLevel::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::LevelControl::Commands::MoveToLevel::Type mRequest;
};

/*
 * Command Move
 */
class LevelControlMove : public ClusterCommand
{
public:
    LevelControlMove(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("move", credsIssuerConfig)
    {
        AddArgument("MoveMode", 0, UINT8_MAX, &mRequest.moveMode);
        AddArgument("Rate", 0, UINT8_MAX, &mRequest.rate);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::LevelControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::LevelControl::Commands::Move::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::LevelControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::LevelControl::Commands::Move::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::LevelControl::Commands::Move::Type mRequest;
};

/*
 * Command Step
 */
class LevelControlStep : public ClusterCommand
{
public:
    LevelControlStep(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("step", credsIssuerConfig)
    {
        AddArgument("StepMode", 0, UINT8_MAX, &mRequest.stepMode);
        AddArgument("StepSize", 0, UINT8_MAX, &mRequest.stepSize);
        AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::LevelControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::LevelControl::Commands::Step::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::LevelControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::LevelControl::Commands::Step::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::LevelControl::Commands::Step::Type mRequest;
};

/*
 * Command Stop
 */
class LevelControlStop : public ClusterCommand
{
public:
    LevelControlStop(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("stop", credsIssuerConfig)
    {
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::LevelControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::LevelControl::Commands::Stop::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::LevelControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::LevelControl::Commands::Stop::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::LevelControl::Commands::Stop::Type mRequest;
};

/*
 * Command MoveToLevelWithOnOff
 */
class LevelControlMoveToLevelWithOnOff : public ClusterCommand
{
public:
    LevelControlMoveToLevelWithOnOff(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("move-to-level-with-on-off", credsIssuerConfig)
    {
        AddArgument("Level", 0, UINT8_MAX, &mRequest.level);
        AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::LevelControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::LevelControl::Commands::MoveToLevelWithOnOff::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::LevelControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::LevelControl::Commands::MoveToLevelWithOnOff::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::LevelControl::Commands::MoveToLevelWithOnOff::Type mRequest;
};

/*
 * Command MoveWithOnOff
 */
class LevelControlMoveWithOnOff : public ClusterCommand
{
public:
    LevelControlMoveWithOnOff(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("move-with-on-off", credsIssuerConfig)
    {
        AddArgument("MoveMode", 0, UINT8_MAX, &mRequest.moveMode);
        AddArgument("Rate", 0, UINT8_MAX, &mRequest.rate);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::LevelControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::LevelControl::Commands::MoveWithOnOff::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::LevelControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::LevelControl::Commands::MoveWithOnOff::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::LevelControl::Commands::MoveWithOnOff::Type mRequest;
};

/*
 * Command StepWithOnOff
 */
class LevelControlStepWithOnOff : public ClusterCommand
{
public:
    LevelControlStepWithOnOff(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("step-with-on-off", credsIssuerConfig)
    {
        AddArgument("StepMode", 0, UINT8_MAX, &mRequest.stepMode);
        AddArgument("StepSize", 0, UINT8_MAX, &mRequest.stepSize);
        AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::LevelControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::LevelControl::Commands::StepWithOnOff::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::LevelControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::LevelControl::Commands::StepWithOnOff::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::LevelControl::Commands::StepWithOnOff::Type mRequest;
};

/*
 * Command StopWithOnOff
 */
class LevelControlStopWithOnOff : public ClusterCommand
{
public:
    LevelControlStopWithOnOff(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("stop-with-on-off", credsIssuerConfig)
    {
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::LevelControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::LevelControl::Commands::StopWithOnOff::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::LevelControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::LevelControl::Commands::StopWithOnOff::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::LevelControl::Commands::StopWithOnOff::Type mRequest;
};

/*
 * Command MoveToClosestFrequency
 */
class LevelControlMoveToClosestFrequency : public ClusterCommand
{
public:
    LevelControlMoveToClosestFrequency(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("move-to-closest-frequency", credsIssuerConfig)
    {
        AddArgument("Frequency", 0, UINT16_MAX, &mRequest.frequency);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::LevelControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::LevelControl::Commands::MoveToClosestFrequency::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::LevelControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::LevelControl::Commands::MoveToClosestFrequency::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::LevelControl::Commands::MoveToClosestFrequency::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster BinaryInputBasic                                            | 0x000F |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * ActiveText                                                        | 0x0004 |
| * Description                                                       | 0x001C |
| * InactiveText                                                      | 0x002E |
| * OutOfService                                                      | 0x0051 |
| * Polarity                                                          | 0x0054 |
| * PresentValue                                                      | 0x0055 |
| * Reliability                                                       | 0x0067 |
| * StatusFlags                                                       | 0x006F |
| * ApplicationType                                                   | 0x0100 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster PulseWidthModulation                                        | 0x001C |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster Descriptor                                                  | 0x001D |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * DeviceTypeList                                                    | 0x0000 |
| * ServerList                                                        | 0x0001 |
| * ClientList                                                        | 0x0002 |
| * PartsList                                                         | 0x0003 |
| * TagList                                                           | 0x0004 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster Binding                                                     | 0x001E |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * Binding                                                           | 0x0000 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster AccessControl                                               | 0x001F |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * Acl                                                               | 0x0000 |
| * Extension                                                         | 0x0001 |
| * SubjectsPerAccessControlEntry                                     | 0x0002 |
| * TargetsPerAccessControlEntry                                      | 0x0003 |
| * AccessControlEntriesPerFabric                                     | 0x0004 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * AccessControlEntryChanged                                         | 0x0000 |
| * AccessControlExtensionChanged                                     | 0x0001 |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster Actions                                                     | 0x0025 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * InstantAction                                                     |   0x00 |
| * InstantActionWithTransition                                       |   0x01 |
| * StartAction                                                       |   0x02 |
| * StartActionWithDuration                                           |   0x03 |
| * StopAction                                                        |   0x04 |
| * PauseAction                                                       |   0x05 |
| * PauseActionWithDuration                                           |   0x06 |
| * ResumeAction                                                      |   0x07 |
| * EnableAction                                                      |   0x08 |
| * EnableActionWithDuration                                          |   0x09 |
| * DisableAction                                                     |   0x0A |
| * DisableActionWithDuration                                         |   0x0B |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * ActionList                                                        | 0x0000 |
| * EndpointLists                                                     | 0x0001 |
| * SetupURL                                                          | 0x0002 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * StateChanged                                                      | 0x0000 |
| * ActionFailed                                                      | 0x0001 |
\*----------------------------------------------------------------------------*/

/*
 * Command InstantAction
 */
class ActionsInstantAction : public ClusterCommand
{
public:
    ActionsInstantAction(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("instant-action", credsIssuerConfig)
    {
        AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
        AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Actions::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Actions::Commands::InstantAction::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Actions::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Actions::Commands::InstantAction::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Actions::Commands::InstantAction::Type mRequest;
};

/*
 * Command InstantActionWithTransition
 */
class ActionsInstantActionWithTransition : public ClusterCommand
{
public:
    ActionsInstantActionWithTransition(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("instant-action-with-transition", credsIssuerConfig)
    {
        AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
        AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
        AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Actions::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Actions::Commands::InstantActionWithTransition::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Actions::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Actions::Commands::InstantActionWithTransition::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Actions::Commands::InstantActionWithTransition::Type mRequest;
};

/*
 * Command StartAction
 */
class ActionsStartAction : public ClusterCommand
{
public:
    ActionsStartAction(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("start-action", credsIssuerConfig)
    {
        AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
        AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Actions::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Actions::Commands::StartAction::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Actions::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Actions::Commands::StartAction::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Actions::Commands::StartAction::Type mRequest;
};

/*
 * Command StartActionWithDuration
 */
class ActionsStartActionWithDuration : public ClusterCommand
{
public:
    ActionsStartActionWithDuration(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("start-action-with-duration", credsIssuerConfig)
    {
        AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
        AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
        AddArgument("Duration", 0, UINT32_MAX, &mRequest.duration);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Actions::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Actions::Commands::StartActionWithDuration::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Actions::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Actions::Commands::StartActionWithDuration::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Actions::Commands::StartActionWithDuration::Type mRequest;
};

/*
 * Command StopAction
 */
class ActionsStopAction : public ClusterCommand
{
public:
    ActionsStopAction(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("stop-action", credsIssuerConfig)
    {
        AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
        AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Actions::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Actions::Commands::StopAction::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Actions::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Actions::Commands::StopAction::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Actions::Commands::StopAction::Type mRequest;
};

/*
 * Command PauseAction
 */
class ActionsPauseAction : public ClusterCommand
{
public:
    ActionsPauseAction(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("pause-action", credsIssuerConfig)
    {
        AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
        AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Actions::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Actions::Commands::PauseAction::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Actions::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Actions::Commands::PauseAction::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Actions::Commands::PauseAction::Type mRequest;
};

/*
 * Command PauseActionWithDuration
 */
class ActionsPauseActionWithDuration : public ClusterCommand
{
public:
    ActionsPauseActionWithDuration(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("pause-action-with-duration", credsIssuerConfig)
    {
        AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
        AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
        AddArgument("Duration", 0, UINT32_MAX, &mRequest.duration);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Actions::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Actions::Commands::PauseActionWithDuration::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Actions::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Actions::Commands::PauseActionWithDuration::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Actions::Commands::PauseActionWithDuration::Type mRequest;
};

/*
 * Command ResumeAction
 */
class ActionsResumeAction : public ClusterCommand
{
public:
    ActionsResumeAction(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("resume-action", credsIssuerConfig)
    {
        AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
        AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Actions::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Actions::Commands::ResumeAction::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Actions::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Actions::Commands::ResumeAction::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Actions::Commands::ResumeAction::Type mRequest;
};

/*
 * Command EnableAction
 */
class ActionsEnableAction : public ClusterCommand
{
public:
    ActionsEnableAction(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("enable-action", credsIssuerConfig)
    {
        AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
        AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Actions::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Actions::Commands::EnableAction::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Actions::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Actions::Commands::EnableAction::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Actions::Commands::EnableAction::Type mRequest;
};

/*
 * Command EnableActionWithDuration
 */
class ActionsEnableActionWithDuration : public ClusterCommand
{
public:
    ActionsEnableActionWithDuration(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("enable-action-with-duration", credsIssuerConfig)
    {
        AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
        AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
        AddArgument("Duration", 0, UINT32_MAX, &mRequest.duration);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Actions::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Actions::Commands::EnableActionWithDuration::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Actions::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Actions::Commands::EnableActionWithDuration::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Actions::Commands::EnableActionWithDuration::Type mRequest;
};

/*
 * Command DisableAction
 */
class ActionsDisableAction : public ClusterCommand
{
public:
    ActionsDisableAction(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("disable-action", credsIssuerConfig)
    {
        AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
        AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Actions::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Actions::Commands::DisableAction::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Actions::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Actions::Commands::DisableAction::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Actions::Commands::DisableAction::Type mRequest;
};

/*
 * Command DisableActionWithDuration
 */
class ActionsDisableActionWithDuration : public ClusterCommand
{
public:
    ActionsDisableActionWithDuration(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("disable-action-with-duration", credsIssuerConfig)
    {
        AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
        AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
        AddArgument("Duration", 0, UINT32_MAX, &mRequest.duration);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Actions::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Actions::Commands::DisableActionWithDuration::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Actions::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Actions::Commands::DisableActionWithDuration::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Actions::Commands::DisableActionWithDuration::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster BasicInformation                                            | 0x0028 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * MfgSpecificPing                                                   |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * DataModelRevision                                                 | 0x0000 |
| * VendorName                                                        | 0x0001 |
| * VendorID                                                          | 0x0002 |
| * ProductName                                                       | 0x0003 |
| * ProductID                                                         | 0x0004 |
| * NodeLabel                                                         | 0x0005 |
| * Location                                                          | 0x0006 |
| * HardwareVersion                                                   | 0x0007 |
| * HardwareVersionString                                             | 0x0008 |
| * SoftwareVersion                                                   | 0x0009 |
| * SoftwareVersionString                                             | 0x000A |
| * ManufacturingDate                                                 | 0x000B |
| * PartNumber                                                        | 0x000C |
| * ProductURL                                                        | 0x000D |
| * ProductLabel                                                      | 0x000E |
| * SerialNumber                                                      | 0x000F |
| * LocalConfigDisabled                                               | 0x0010 |
| * Reachable                                                         | 0x0011 |
| * UniqueID                                                          | 0x0012 |
| * CapabilityMinima                                                  | 0x0013 |
| * ProductAppearance                                                 | 0x0014 |
| * SpecificationVersion                                              | 0x0015 |
| * MaxPathsPerInvoke                                                 | 0x0016 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * StartUp                                                           | 0x0000 |
| * ShutDown                                                          | 0x0001 |
| * Leave                                                             | 0x0002 |
| * ReachableChanged                                                  | 0x0003 |
\*----------------------------------------------------------------------------*/

/*
 * Command MfgSpecificPing
 */
class BasicInformationMfgSpecificPing : public ClusterCommand
{
public:
    BasicInformationMfgSpecificPing(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("mfg-specific-ping", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::BasicInformation::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::BasicInformation::Commands::MfgSpecificPing::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::BasicInformation::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::BasicInformation::Commands::MfgSpecificPing::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::BasicInformation::Commands::MfgSpecificPing::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster OtaSoftwareUpdateProvider                                   | 0x0029 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * QueryImage                                                        |   0x00 |
| * ApplyUpdateRequest                                                |   0x02 |
| * NotifyUpdateApplied                                               |   0x04 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command QueryImage
 */
class OtaSoftwareUpdateProviderQueryImage : public ClusterCommand
{
public:
    OtaSoftwareUpdateProviderQueryImage(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("query-image", credsIssuerConfig), mComplex_ProtocolsSupported(&mRequest.protocolsSupported)
    {
        AddArgument("VendorID", 0, UINT16_MAX, &mRequest.vendorID);
        AddArgument("ProductID", 0, UINT16_MAX, &mRequest.productID);
        AddArgument("SoftwareVersion", 0, UINT32_MAX, &mRequest.softwareVersion);
        AddArgument("ProtocolsSupported", &mComplex_ProtocolsSupported);
        AddArgument("HardwareVersion", 0, UINT16_MAX, &mRequest.hardwareVersion);
        AddArgument("Location", &mRequest.location);
        AddArgument("RequestorCanConsent", 0, 1, &mRequest.requestorCanConsent);
        AddArgument("MetadataForProvider", &mRequest.metadataForProvider);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OtaSoftwareUpdateProvider::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OtaSoftwareUpdateProvider::Commands::QueryImage::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OtaSoftwareUpdateProvider::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OtaSoftwareUpdateProvider::Commands::QueryImage::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::OtaSoftwareUpdateProvider::Commands::QueryImage::Type mRequest;
    TypedComplexArgument<chip::app::DataModel::List<const chip::app::Clusters::OtaSoftwareUpdateProvider::DownloadProtocolEnum>>
        mComplex_ProtocolsSupported;
};

/*
 * Command ApplyUpdateRequest
 */
class OtaSoftwareUpdateProviderApplyUpdateRequest : public ClusterCommand
{
public:
    OtaSoftwareUpdateProviderApplyUpdateRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("apply-update-request", credsIssuerConfig)
    {
        AddArgument("UpdateToken", &mRequest.updateToken);
        AddArgument("NewVersion", 0, UINT32_MAX, &mRequest.newVersion);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OtaSoftwareUpdateProvider::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OtaSoftwareUpdateProvider::Commands::ApplyUpdateRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OtaSoftwareUpdateProvider::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OtaSoftwareUpdateProvider::Commands::ApplyUpdateRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::OtaSoftwareUpdateProvider::Commands::ApplyUpdateRequest::Type mRequest;
};

/*
 * Command NotifyUpdateApplied
 */
class OtaSoftwareUpdateProviderNotifyUpdateApplied : public ClusterCommand
{
public:
    OtaSoftwareUpdateProviderNotifyUpdateApplied(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("notify-update-applied", credsIssuerConfig)
    {
        AddArgument("UpdateToken", &mRequest.updateToken);
        AddArgument("SoftwareVersion", 0, UINT32_MAX, &mRequest.softwareVersion);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OtaSoftwareUpdateProvider::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OtaSoftwareUpdateProvider::Commands::NotifyUpdateApplied::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OtaSoftwareUpdateProvider::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OtaSoftwareUpdateProvider::Commands::NotifyUpdateApplied::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::OtaSoftwareUpdateProvider::Commands::NotifyUpdateApplied::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster OtaSoftwareUpdateRequestor                                  | 0x002A |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * AnnounceOTAProvider                                               |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * DefaultOTAProviders                                               | 0x0000 |
| * UpdatePossible                                                    | 0x0001 |
| * UpdateState                                                       | 0x0002 |
| * UpdateStateProgress                                               | 0x0003 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * StateTransition                                                   | 0x0000 |
| * VersionApplied                                                    | 0x0001 |
| * DownloadError                                                     | 0x0002 |
\*----------------------------------------------------------------------------*/

/*
 * Command AnnounceOTAProvider
 */
class OtaSoftwareUpdateRequestorAnnounceOTAProvider : public ClusterCommand
{
public:
    OtaSoftwareUpdateRequestorAnnounceOTAProvider(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("announce-otaprovider", credsIssuerConfig)
    {
        AddArgument("ProviderNodeID", 0, UINT64_MAX, &mRequest.providerNodeID);
        AddArgument("VendorID", 0, UINT16_MAX, &mRequest.vendorID);
        AddArgument("AnnouncementReason", 0, UINT8_MAX, &mRequest.announcementReason);
        AddArgument("MetadataForNode", &mRequest.metadataForNode);
        AddArgument("Endpoint", 0, UINT16_MAX, &mRequest.endpoint);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OtaSoftwareUpdateRequestor::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OtaSoftwareUpdateRequestor::Commands::AnnounceOTAProvider::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OtaSoftwareUpdateRequestor::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OtaSoftwareUpdateRequestor::Commands::AnnounceOTAProvider::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::OtaSoftwareUpdateRequestor::Commands::AnnounceOTAProvider::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster LocalizationConfiguration                                   | 0x002B |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * ActiveLocale                                                      | 0x0000 |
| * SupportedLocales                                                  | 0x0001 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster TimeFormatLocalization                                      | 0x002C |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * HourFormat                                                        | 0x0000 |
| * ActiveCalendarType                                                | 0x0001 |
| * SupportedCalendarTypes                                            | 0x0002 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster UnitLocalization                                            | 0x002D |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * TemperatureUnit                                                   | 0x0000 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster PowerSourceConfiguration                                    | 0x002E |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * Sources                                                           | 0x0000 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster PowerSource                                                 | 0x002F |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * Status                                                            | 0x0000 |
| * Order                                                             | 0x0001 |
| * Description                                                       | 0x0002 |
| * WiredAssessedInputVoltage                                         | 0x0003 |
| * WiredAssessedInputFrequency                                       | 0x0004 |
| * WiredCurrentType                                                  | 0x0005 |
| * WiredAssessedCurrent                                              | 0x0006 |
| * WiredNominalVoltage                                               | 0x0007 |
| * WiredMaximumCurrent                                               | 0x0008 |
| * WiredPresent                                                      | 0x0009 |
| * ActiveWiredFaults                                                 | 0x000A |
| * BatVoltage                                                        | 0x000B |
| * BatPercentRemaining                                               | 0x000C |
| * BatTimeRemaining                                                  | 0x000D |
| * BatChargeLevel                                                    | 0x000E |
| * BatReplacementNeeded                                              | 0x000F |
| * BatReplaceability                                                 | 0x0010 |
| * BatPresent                                                        | 0x0011 |
| * ActiveBatFaults                                                   | 0x0012 |
| * BatReplacementDescription                                         | 0x0013 |
| * BatCommonDesignation                                              | 0x0014 |
| * BatANSIDesignation                                                | 0x0015 |
| * BatIECDesignation                                                 | 0x0016 |
| * BatApprovedChemistry                                              | 0x0017 |
| * BatCapacity                                                       | 0x0018 |
| * BatQuantity                                                       | 0x0019 |
| * BatChargeState                                                    | 0x001A |
| * BatTimeToFullCharge                                               | 0x001B |
| * BatFunctionalWhileCharging                                        | 0x001C |
| * BatChargingCurrent                                                | 0x001D |
| * ActiveBatChargeFaults                                             | 0x001E |
| * EndpointList                                                      | 0x001F |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * WiredFaultChange                                                  | 0x0000 |
| * BatFaultChange                                                    | 0x0001 |
| * BatChargeFaultChange                                              | 0x0002 |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster GeneralCommissioning                                        | 0x0030 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * ArmFailSafe                                                       |   0x00 |
| * SetRegulatoryConfig                                               |   0x02 |
| * CommissioningComplete                                             |   0x04 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * Breadcrumb                                                        | 0x0000 |
| * BasicCommissioningInfo                                            | 0x0001 |
| * RegulatoryConfig                                                  | 0x0002 |
| * LocationCapability                                                | 0x0003 |
| * SupportsConcurrentConnection                                      | 0x0004 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command ArmFailSafe
 */
class GeneralCommissioningArmFailSafe : public ClusterCommand
{
public:
    GeneralCommissioningArmFailSafe(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("arm-fail-safe", credsIssuerConfig)
    {
        AddArgument("ExpiryLengthSeconds", 0, UINT16_MAX, &mRequest.expiryLengthSeconds);
        AddArgument("Breadcrumb", 0, UINT64_MAX, &mRequest.breadcrumb);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::GeneralCommissioning::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::GeneralCommissioning::Commands::ArmFailSafe::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::GeneralCommissioning::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::GeneralCommissioning::Commands::ArmFailSafe::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::GeneralCommissioning::Commands::ArmFailSafe::Type mRequest;
};

/*
 * Command SetRegulatoryConfig
 */
class GeneralCommissioningSetRegulatoryConfig : public ClusterCommand
{
public:
    GeneralCommissioningSetRegulatoryConfig(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("set-regulatory-config", credsIssuerConfig)
    {
        AddArgument("NewRegulatoryConfig", 0, UINT8_MAX, &mRequest.newRegulatoryConfig);
        AddArgument("CountryCode", &mRequest.countryCode);
        AddArgument("Breadcrumb", 0, UINT64_MAX, &mRequest.breadcrumb);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::GeneralCommissioning::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::GeneralCommissioning::Commands::SetRegulatoryConfig::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::GeneralCommissioning::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::GeneralCommissioning::Commands::SetRegulatoryConfig::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::GeneralCommissioning::Commands::SetRegulatoryConfig::Type mRequest;
};

/*
 * Command CommissioningComplete
 */
class GeneralCommissioningCommissioningComplete : public ClusterCommand
{
public:
    GeneralCommissioningCommissioningComplete(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("commissioning-complete", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::GeneralCommissioning::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::GeneralCommissioning::Commands::CommissioningComplete::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::GeneralCommissioning::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::GeneralCommissioning::Commands::CommissioningComplete::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::GeneralCommissioning::Commands::CommissioningComplete::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster NetworkCommissioning                                        | 0x0031 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * ScanNetworks                                                      |   0x00 |
| * AddOrUpdateWiFiNetwork                                            |   0x02 |
| * AddOrUpdateThreadNetwork                                          |   0x03 |
| * RemoveNetwork                                                     |   0x04 |
| * ConnectNetwork                                                    |   0x06 |
| * ReorderNetwork                                                    |   0x08 |
| * QueryIdentity                                                     |   0x09 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * MaxNetworks                                                       | 0x0000 |
| * Networks                                                          | 0x0001 |
| * ScanMaxTimeSeconds                                                | 0x0002 |
| * ConnectMaxTimeSeconds                                             | 0x0003 |
| * InterfaceEnabled                                                  | 0x0004 |
| * LastNetworkingStatus                                              | 0x0005 |
| * LastNetworkID                                                     | 0x0006 |
| * LastConnectErrorValue                                             | 0x0007 |
| * SupportedWiFiBands                                                | 0x0008 |
| * SupportedThreadFeatures                                           | 0x0009 |
| * ThreadVersion                                                     | 0x000A |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command ScanNetworks
 */
class NetworkCommissioningScanNetworks : public ClusterCommand
{
public:
    NetworkCommissioningScanNetworks(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("scan-networks", credsIssuerConfig)
    {
        AddArgument("Ssid", &mRequest.ssid);
        AddArgument("Breadcrumb", 0, UINT64_MAX, &mRequest.breadcrumb);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::NetworkCommissioning::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::NetworkCommissioning::Commands::ScanNetworks::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::NetworkCommissioning::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::NetworkCommissioning::Commands::ScanNetworks::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::NetworkCommissioning::Commands::ScanNetworks::Type mRequest;
};

/*
 * Command AddOrUpdateWiFiNetwork
 */
class NetworkCommissioningAddOrUpdateWiFiNetwork : public ClusterCommand
{
public:
    NetworkCommissioningAddOrUpdateWiFiNetwork(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("add-or-update-wi-fi-network", credsIssuerConfig)
    {
        AddArgument("Ssid", &mRequest.ssid);
        AddArgument("Credentials", &mRequest.credentials);
        AddArgument("Breadcrumb", 0, UINT64_MAX, &mRequest.breadcrumb);
        AddArgument("NetworkIdentity", &mRequest.networkIdentity);
        AddArgument("ClientIdentifier", &mRequest.clientIdentifier);
        AddArgument("PossessionNonce", &mRequest.possessionNonce);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::NetworkCommissioning::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::NetworkCommissioning::Commands::AddOrUpdateWiFiNetwork::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::NetworkCommissioning::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::NetworkCommissioning::Commands::AddOrUpdateWiFiNetwork::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::NetworkCommissioning::Commands::AddOrUpdateWiFiNetwork::Type mRequest;
};

/*
 * Command AddOrUpdateThreadNetwork
 */
class NetworkCommissioningAddOrUpdateThreadNetwork : public ClusterCommand
{
public:
    NetworkCommissioningAddOrUpdateThreadNetwork(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("add-or-update-thread-network", credsIssuerConfig)
    {
        AddArgument("OperationalDataset", &mRequest.operationalDataset);
        AddArgument("Breadcrumb", 0, UINT64_MAX, &mRequest.breadcrumb);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::NetworkCommissioning::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::NetworkCommissioning::Commands::AddOrUpdateThreadNetwork::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::NetworkCommissioning::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::NetworkCommissioning::Commands::AddOrUpdateThreadNetwork::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::NetworkCommissioning::Commands::AddOrUpdateThreadNetwork::Type mRequest;
};

/*
 * Command RemoveNetwork
 */
class NetworkCommissioningRemoveNetwork : public ClusterCommand
{
public:
    NetworkCommissioningRemoveNetwork(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("remove-network", credsIssuerConfig)
    {
        AddArgument("NetworkID", &mRequest.networkID);
        AddArgument("Breadcrumb", 0, UINT64_MAX, &mRequest.breadcrumb);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::NetworkCommissioning::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::NetworkCommissioning::Commands::RemoveNetwork::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::NetworkCommissioning::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::NetworkCommissioning::Commands::RemoveNetwork::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::NetworkCommissioning::Commands::RemoveNetwork::Type mRequest;
};

/*
 * Command ConnectNetwork
 */
class NetworkCommissioningConnectNetwork : public ClusterCommand
{
public:
    NetworkCommissioningConnectNetwork(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("connect-network", credsIssuerConfig)
    {
        AddArgument("NetworkID", &mRequest.networkID);
        AddArgument("Breadcrumb", 0, UINT64_MAX, &mRequest.breadcrumb);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::NetworkCommissioning::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::NetworkCommissioning::Commands::ConnectNetwork::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::NetworkCommissioning::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::NetworkCommissioning::Commands::ConnectNetwork::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::NetworkCommissioning::Commands::ConnectNetwork::Type mRequest;
};

/*
 * Command ReorderNetwork
 */
class NetworkCommissioningReorderNetwork : public ClusterCommand
{
public:
    NetworkCommissioningReorderNetwork(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("reorder-network", credsIssuerConfig)
    {
        AddArgument("NetworkID", &mRequest.networkID);
        AddArgument("NetworkIndex", 0, UINT8_MAX, &mRequest.networkIndex);
        AddArgument("Breadcrumb", 0, UINT64_MAX, &mRequest.breadcrumb);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::NetworkCommissioning::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::NetworkCommissioning::Commands::ReorderNetwork::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::NetworkCommissioning::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::NetworkCommissioning::Commands::ReorderNetwork::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::NetworkCommissioning::Commands::ReorderNetwork::Type mRequest;
};

/*
 * Command QueryIdentity
 */
class NetworkCommissioningQueryIdentity : public ClusterCommand
{
public:
    NetworkCommissioningQueryIdentity(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("query-identity", credsIssuerConfig)
    {
        AddArgument("KeyIdentifier", &mRequest.keyIdentifier);
        AddArgument("PossessionNonce", &mRequest.possessionNonce);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::NetworkCommissioning::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::NetworkCommissioning::Commands::QueryIdentity::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::NetworkCommissioning::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::NetworkCommissioning::Commands::QueryIdentity::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::NetworkCommissioning::Commands::QueryIdentity::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster DiagnosticLogs                                              | 0x0032 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * RetrieveLogsRequest                                               |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command RetrieveLogsRequest
 */
class DiagnosticLogsRetrieveLogsRequest : public ClusterCommand
{
public:
    DiagnosticLogsRetrieveLogsRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("retrieve-logs-request", credsIssuerConfig)
    {
        AddArgument("Intent", 0, UINT8_MAX, &mRequest.intent);
        AddArgument("RequestedProtocol", 0, UINT8_MAX, &mRequest.requestedProtocol);
        AddArgument("TransferFileDesignator", &mRequest.transferFileDesignator);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DiagnosticLogs::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DiagnosticLogs::Commands::RetrieveLogsRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DiagnosticLogs::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DiagnosticLogs::Commands::RetrieveLogsRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DiagnosticLogs::Commands::RetrieveLogsRequest::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster GeneralDiagnostics                                          | 0x0033 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * TestEventTrigger                                                  |   0x00 |
| * TimeSnapshot                                                      |   0x01 |
| * PayloadTestRequest                                                |   0x03 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * NetworkInterfaces                                                 | 0x0000 |
| * RebootCount                                                       | 0x0001 |
| * UpTime                                                            | 0x0002 |
| * TotalOperationalHours                                             | 0x0003 |
| * BootReason                                                        | 0x0004 |
| * ActiveHardwareFaults                                              | 0x0005 |
| * ActiveRadioFaults                                                 | 0x0006 |
| * ActiveNetworkFaults                                               | 0x0007 |
| * TestEventTriggersEnabled                                          | 0x0008 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * HardwareFaultChange                                               | 0x0000 |
| * RadioFaultChange                                                  | 0x0001 |
| * NetworkFaultChange                                                | 0x0002 |
| * BootReason                                                        | 0x0003 |
\*----------------------------------------------------------------------------*/

/*
 * Command TestEventTrigger
 */
class GeneralDiagnosticsTestEventTrigger : public ClusterCommand
{
public:
    GeneralDiagnosticsTestEventTrigger(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("test-event-trigger", credsIssuerConfig)
    {
        AddArgument("EnableKey", &mRequest.enableKey);
        AddArgument("EventTrigger", 0, UINT64_MAX, &mRequest.eventTrigger);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::GeneralDiagnostics::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::GeneralDiagnostics::Commands::TestEventTrigger::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::GeneralDiagnostics::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::GeneralDiagnostics::Commands::TestEventTrigger::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::GeneralDiagnostics::Commands::TestEventTrigger::Type mRequest;
};

/*
 * Command TimeSnapshot
 */
class GeneralDiagnosticsTimeSnapshot : public ClusterCommand
{
public:
    GeneralDiagnosticsTimeSnapshot(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("time-snapshot", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::GeneralDiagnostics::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::GeneralDiagnostics::Commands::TimeSnapshot::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::GeneralDiagnostics::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::GeneralDiagnostics::Commands::TimeSnapshot::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::GeneralDiagnostics::Commands::TimeSnapshot::Type mRequest;
};

/*
 * Command PayloadTestRequest
 */
class GeneralDiagnosticsPayloadTestRequest : public ClusterCommand
{
public:
    GeneralDiagnosticsPayloadTestRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("payload-test-request", credsIssuerConfig)
    {
        AddArgument("EnableKey", &mRequest.enableKey);
        AddArgument("Value", 0, UINT8_MAX, &mRequest.value);
        AddArgument("Count", 0, UINT16_MAX, &mRequest.count);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::GeneralDiagnostics::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::GeneralDiagnostics::Commands::PayloadTestRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::GeneralDiagnostics::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::GeneralDiagnostics::Commands::PayloadTestRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::GeneralDiagnostics::Commands::PayloadTestRequest::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster SoftwareDiagnostics                                         | 0x0034 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * ResetWatermarks                                                   |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * ThreadMetrics                                                     | 0x0000 |
| * CurrentHeapFree                                                   | 0x0001 |
| * CurrentHeapUsed                                                   | 0x0002 |
| * CurrentHeapHighWatermark                                          | 0x0003 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * SoftwareFault                                                     | 0x0000 |
\*----------------------------------------------------------------------------*/

/*
 * Command ResetWatermarks
 */
class SoftwareDiagnosticsResetWatermarks : public ClusterCommand
{
public:
    SoftwareDiagnosticsResetWatermarks(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("reset-watermarks", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::SoftwareDiagnostics::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::SoftwareDiagnostics::Commands::ResetWatermarks::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::SoftwareDiagnostics::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::SoftwareDiagnostics::Commands::ResetWatermarks::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::SoftwareDiagnostics::Commands::ResetWatermarks::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster ThreadNetworkDiagnostics                                    | 0x0035 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * ResetCounts                                                       |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * Channel                                                           | 0x0000 |
| * RoutingRole                                                       | 0x0001 |
| * NetworkName                                                       | 0x0002 |
| * PanId                                                             | 0x0003 |
| * ExtendedPanId                                                     | 0x0004 |
| * MeshLocalPrefix                                                   | 0x0005 |
| * OverrunCount                                                      | 0x0006 |
| * NeighborTable                                                     | 0x0007 |
| * RouteTable                                                        | 0x0008 |
| * PartitionId                                                       | 0x0009 |
| * Weighting                                                         | 0x000A |
| * DataVersion                                                       | 0x000B |
| * StableDataVersion                                                 | 0x000C |
| * LeaderRouterId                                                    | 0x000D |
| * DetachedRoleCount                                                 | 0x000E |
| * ChildRoleCount                                                    | 0x000F |
| * RouterRoleCount                                                   | 0x0010 |
| * LeaderRoleCount                                                   | 0x0011 |
| * AttachAttemptCount                                                | 0x0012 |
| * PartitionIdChangeCount                                            | 0x0013 |
| * BetterPartitionAttachAttemptCount                                 | 0x0014 |
| * ParentChangeCount                                                 | 0x0015 |
| * TxTotalCount                                                      | 0x0016 |
| * TxUnicastCount                                                    | 0x0017 |
| * TxBroadcastCount                                                  | 0x0018 |
| * TxAckRequestedCount                                               | 0x0019 |
| * TxAckedCount                                                      | 0x001A |
| * TxNoAckRequestedCount                                             | 0x001B |
| * TxDataCount                                                       | 0x001C |
| * TxDataPollCount                                                   | 0x001D |
| * TxBeaconCount                                                     | 0x001E |
| * TxBeaconRequestCount                                              | 0x001F |
| * TxOtherCount                                                      | 0x0020 |
| * TxRetryCount                                                      | 0x0021 |
| * TxDirectMaxRetryExpiryCount                                       | 0x0022 |
| * TxIndirectMaxRetryExpiryCount                                     | 0x0023 |
| * TxErrCcaCount                                                     | 0x0024 |
| * TxErrAbortCount                                                   | 0x0025 |
| * TxErrBusyChannelCount                                             | 0x0026 |
| * RxTotalCount                                                      | 0x0027 |
| * RxUnicastCount                                                    | 0x0028 |
| * RxBroadcastCount                                                  | 0x0029 |
| * RxDataCount                                                       | 0x002A |
| * RxDataPollCount                                                   | 0x002B |
| * RxBeaconCount                                                     | 0x002C |
| * RxBeaconRequestCount                                              | 0x002D |
| * RxOtherCount                                                      | 0x002E |
| * RxAddressFilteredCount                                            | 0x002F |
| * RxDestAddrFilteredCount                                           | 0x0030 |
| * RxDuplicatedCount                                                 | 0x0031 |
| * RxErrNoFrameCount                                                 | 0x0032 |
| * RxErrUnknownNeighborCount                                         | 0x0033 |
| * RxErrInvalidSrcAddrCount                                          | 0x0034 |
| * RxErrSecCount                                                     | 0x0035 |
| * RxErrFcsCount                                                     | 0x0036 |
| * RxErrOtherCount                                                   | 0x0037 |
| * ActiveTimestamp                                                   | 0x0038 |
| * PendingTimestamp                                                  | 0x0039 |
| * Delay                                                             | 0x003A |
| * SecurityPolicy                                                    | 0x003B |
| * ChannelPage0Mask                                                  | 0x003C |
| * OperationalDatasetComponents                                      | 0x003D |
| * ActiveNetworkFaultsList                                           | 0x003E |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * ConnectionStatus                                                  | 0x0000 |
| * NetworkFaultChange                                                | 0x0001 |
\*----------------------------------------------------------------------------*/

/*
 * Command ResetCounts
 */
class ThreadNetworkDiagnosticsResetCounts : public ClusterCommand
{
public:
    ThreadNetworkDiagnosticsResetCounts(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("reset-counts", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadNetworkDiagnostics::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ThreadNetworkDiagnostics::Commands::ResetCounts::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ThreadNetworkDiagnostics::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ThreadNetworkDiagnostics::Commands::ResetCounts::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ThreadNetworkDiagnostics::Commands::ResetCounts::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster WiFiNetworkDiagnostics                                      | 0x0036 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * ResetCounts                                                       |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * Bssid                                                             | 0x0000 |
| * SecurityType                                                      | 0x0001 |
| * WiFiVersion                                                       | 0x0002 |
| * ChannelNumber                                                     | 0x0003 |
| * Rssi                                                              | 0x0004 |
| * BeaconLostCount                                                   | 0x0005 |
| * BeaconRxCount                                                     | 0x0006 |
| * PacketMulticastRxCount                                            | 0x0007 |
| * PacketMulticastTxCount                                            | 0x0008 |
| * PacketUnicastRxCount                                              | 0x0009 |
| * PacketUnicastTxCount                                              | 0x000A |
| * CurrentMaxRate                                                    | 0x000B |
| * OverrunCount                                                      | 0x000C |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * Disconnection                                                     | 0x0000 |
| * AssociationFailure                                                | 0x0001 |
| * ConnectionStatus                                                  | 0x0002 |
\*----------------------------------------------------------------------------*/

/*
 * Command ResetCounts
 */
class WiFiNetworkDiagnosticsResetCounts : public ClusterCommand
{
public:
    WiFiNetworkDiagnosticsResetCounts(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("reset-counts", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::WiFiNetworkDiagnostics::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::WiFiNetworkDiagnostics::Commands::ResetCounts::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::WiFiNetworkDiagnostics::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::WiFiNetworkDiagnostics::Commands::ResetCounts::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::WiFiNetworkDiagnostics::Commands::ResetCounts::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster EthernetNetworkDiagnostics                                  | 0x0037 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * ResetCounts                                                       |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * PHYRate                                                           | 0x0000 |
| * FullDuplex                                                        | 0x0001 |
| * PacketRxCount                                                     | 0x0002 |
| * PacketTxCount                                                     | 0x0003 |
| * TxErrCount                                                        | 0x0004 |
| * CollisionCount                                                    | 0x0005 |
| * OverrunCount                                                      | 0x0006 |
| * CarrierDetect                                                     | 0x0007 |
| * TimeSinceReset                                                    | 0x0008 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command ResetCounts
 */
class EthernetNetworkDiagnosticsResetCounts : public ClusterCommand
{
public:
    EthernetNetworkDiagnosticsResetCounts(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("reset-counts", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::EthernetNetworkDiagnostics::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::EthernetNetworkDiagnostics::Commands::ResetCounts::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::EthernetNetworkDiagnostics::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::EthernetNetworkDiagnostics::Commands::ResetCounts::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::EthernetNetworkDiagnostics::Commands::ResetCounts::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster TimeSynchronization                                         | 0x0038 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * SetUTCTime                                                        |   0x00 |
| * SetTrustedTimeSource                                              |   0x01 |
| * SetTimeZone                                                       |   0x02 |
| * SetDSTOffset                                                      |   0x04 |
| * SetDefaultNTP                                                     |   0x05 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * UTCTime                                                           | 0x0000 |
| * Granularity                                                       | 0x0001 |
| * TimeSource                                                        | 0x0002 |
| * TrustedTimeSource                                                 | 0x0003 |
| * DefaultNTP                                                        | 0x0004 |
| * TimeZone                                                          | 0x0005 |
| * DSTOffset                                                         | 0x0006 |
| * LocalTime                                                         | 0x0007 |
| * TimeZoneDatabase                                                  | 0x0008 |
| * NTPServerAvailable                                                | 0x0009 |
| * TimeZoneListMaxSize                                               | 0x000A |
| * DSTOffsetListMaxSize                                              | 0x000B |
| * SupportsDNSResolve                                                | 0x000C |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * DSTTableEmpty                                                     | 0x0000 |
| * DSTStatus                                                         | 0x0001 |
| * TimeZoneStatus                                                    | 0x0002 |
| * TimeFailure                                                       | 0x0003 |
| * MissingTrustedTimeSource                                          | 0x0004 |
\*----------------------------------------------------------------------------*/

/*
 * Command SetUTCTime
 */
class TimeSynchronizationSetUTCTime : public ClusterCommand
{
public:
    TimeSynchronizationSetUTCTime(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("set-utctime", credsIssuerConfig)
    {
        AddArgument("UTCTime", 0, UINT64_MAX, &mRequest.UTCTime);
        AddArgument("Granularity", 0, UINT8_MAX, &mRequest.granularity);
        AddArgument("TimeSource", 0, UINT8_MAX, &mRequest.timeSource);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::TimeSynchronization::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::TimeSynchronization::Commands::SetUTCTime::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::TimeSynchronization::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::TimeSynchronization::Commands::SetUTCTime::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::TimeSynchronization::Commands::SetUTCTime::Type mRequest;
};

/*
 * Command SetTrustedTimeSource
 */
class TimeSynchronizationSetTrustedTimeSource : public ClusterCommand
{
public:
    TimeSynchronizationSetTrustedTimeSource(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("set-trusted-time-source", credsIssuerConfig), mComplex_TrustedTimeSource(&mRequest.trustedTimeSource)
    {
        AddArgument("TrustedTimeSource", &mComplex_TrustedTimeSource);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::TimeSynchronization::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::TimeSynchronization::Commands::SetTrustedTimeSource::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::TimeSynchronization::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::TimeSynchronization::Commands::SetTrustedTimeSource::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::TimeSynchronization::Commands::SetTrustedTimeSource::Type mRequest;
    TypedComplexArgument<chip::app::DataModel::Nullable<
        chip::app::Clusters::TimeSynchronization::Structs::FabricScopedTrustedTimeSourceStruct::Type>>
        mComplex_TrustedTimeSource;
};

/*
 * Command SetTimeZone
 */
class TimeSynchronizationSetTimeZone : public ClusterCommand
{
public:
    TimeSynchronizationSetTimeZone(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("set-time-zone", credsIssuerConfig), mComplex_TimeZone(&mRequest.timeZone)
    {
        AddArgument("TimeZone", &mComplex_TimeZone);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::TimeSynchronization::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::TimeSynchronization::Commands::SetTimeZone::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::TimeSynchronization::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::TimeSynchronization::Commands::SetTimeZone::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::TimeSynchronization::Commands::SetTimeZone::Type mRequest;
    TypedComplexArgument<chip::app::DataModel::List<const chip::app::Clusters::TimeSynchronization::Structs::TimeZoneStruct::Type>>
        mComplex_TimeZone;
};

/*
 * Command SetDSTOffset
 */
class TimeSynchronizationSetDSTOffset : public ClusterCommand
{
public:
    TimeSynchronizationSetDSTOffset(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("set-dstoffset", credsIssuerConfig), mComplex_DSTOffset(&mRequest.DSTOffset)
    {
        AddArgument("DSTOffset", &mComplex_DSTOffset);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::TimeSynchronization::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::TimeSynchronization::Commands::SetDSTOffset::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::TimeSynchronization::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::TimeSynchronization::Commands::SetDSTOffset::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::TimeSynchronization::Commands::SetDSTOffset::Type mRequest;
    TypedComplexArgument<chip::app::DataModel::List<const chip::app::Clusters::TimeSynchronization::Structs::DSTOffsetStruct::Type>>
        mComplex_DSTOffset;
};

/*
 * Command SetDefaultNTP
 */
class TimeSynchronizationSetDefaultNTP : public ClusterCommand
{
public:
    TimeSynchronizationSetDefaultNTP(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("set-default-ntp", credsIssuerConfig)
    {
        AddArgument("DefaultNTP", &mRequest.defaultNTP);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::TimeSynchronization::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::TimeSynchronization::Commands::SetDefaultNTP::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::TimeSynchronization::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::TimeSynchronization::Commands::SetDefaultNTP::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::TimeSynchronization::Commands::SetDefaultNTP::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster BridgedDeviceBasicInformation                               | 0x0039 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * VendorName                                                        | 0x0001 |
| * VendorID                                                          | 0x0002 |
| * ProductName                                                       | 0x0003 |
| * NodeLabel                                                         | 0x0005 |
| * HardwareVersion                                                   | 0x0007 |
| * HardwareVersionString                                             | 0x0008 |
| * SoftwareVersion                                                   | 0x0009 |
| * SoftwareVersionString                                             | 0x000A |
| * ManufacturingDate                                                 | 0x000B |
| * PartNumber                                                        | 0x000C |
| * ProductURL                                                        | 0x000D |
| * ProductLabel                                                      | 0x000E |
| * SerialNumber                                                      | 0x000F |
| * Reachable                                                         | 0x0011 |
| * UniqueID                                                          | 0x0012 |
| * ProductAppearance                                                 | 0x0014 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * StartUp                                                           | 0x0000 |
| * ShutDown                                                          | 0x0001 |
| * Leave                                                             | 0x0002 |
| * ReachableChanged                                                  | 0x0003 |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster Switch                                                      | 0x003B |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * NumberOfPositions                                                 | 0x0000 |
| * CurrentPosition                                                   | 0x0001 |
| * MultiPressMax                                                     | 0x0002 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * SwitchLatched                                                     | 0x0000 |
| * InitialPress                                                      | 0x0001 |
| * LongPress                                                         | 0x0002 |
| * ShortRelease                                                      | 0x0003 |
| * LongRelease                                                       | 0x0004 |
| * MultiPressOngoing                                                 | 0x0005 |
| * MultiPressComplete                                                | 0x0006 |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster AdministratorCommissioning                                  | 0x003C |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * OpenCommissioningWindow                                           |   0x00 |
| * OpenBasicCommissioningWindow                                      |   0x01 |
| * RevokeCommissioning                                               |   0x02 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * WindowStatus                                                      | 0x0000 |
| * AdminFabricIndex                                                  | 0x0001 |
| * AdminVendorId                                                     | 0x0002 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command OpenCommissioningWindow
 */
class AdministratorCommissioningOpenCommissioningWindow : public ClusterCommand
{
public:
    AdministratorCommissioningOpenCommissioningWindow(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("open-commissioning-window", credsIssuerConfig)
    {
        AddArgument("CommissioningTimeout", 0, UINT16_MAX, &mRequest.commissioningTimeout);
        AddArgument("PAKEPasscodeVerifier", &mRequest.PAKEPasscodeVerifier);
        AddArgument("Discriminator", 0, UINT16_MAX, &mRequest.discriminator);
        AddArgument("Iterations", 0, UINT32_MAX, &mRequest.iterations);
        AddArgument("Salt", &mRequest.salt);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::AdministratorCommissioning::Id;
        constexpr chip::CommandId commandId =
            chip::app::Clusters::AdministratorCommissioning::Commands::OpenCommissioningWindow::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::AdministratorCommissioning::Id;
        constexpr chip::CommandId commandId =
            chip::app::Clusters::AdministratorCommissioning::Commands::OpenCommissioningWindow::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::AdministratorCommissioning::Commands::OpenCommissioningWindow::Type mRequest;
};

/*
 * Command OpenBasicCommissioningWindow
 */
class AdministratorCommissioningOpenBasicCommissioningWindow : public ClusterCommand
{
public:
    AdministratorCommissioningOpenBasicCommissioningWindow(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("open-basic-commissioning-window", credsIssuerConfig)
    {
        AddArgument("CommissioningTimeout", 0, UINT16_MAX, &mRequest.commissioningTimeout);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::AdministratorCommissioning::Id;
        constexpr chip::CommandId commandId =
            chip::app::Clusters::AdministratorCommissioning::Commands::OpenBasicCommissioningWindow::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::AdministratorCommissioning::Id;
        constexpr chip::CommandId commandId =
            chip::app::Clusters::AdministratorCommissioning::Commands::OpenBasicCommissioningWindow::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::AdministratorCommissioning::Commands::OpenBasicCommissioningWindow::Type mRequest;
};

/*
 * Command RevokeCommissioning
 */
class AdministratorCommissioningRevokeCommissioning : public ClusterCommand
{
public:
    AdministratorCommissioningRevokeCommissioning(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("revoke-commissioning", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::AdministratorCommissioning::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::AdministratorCommissioning::Commands::RevokeCommissioning::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::AdministratorCommissioning::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::AdministratorCommissioning::Commands::RevokeCommissioning::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::AdministratorCommissioning::Commands::RevokeCommissioning::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster OperationalCredentials                                      | 0x003E |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * AttestationRequest                                                |   0x00 |
| * CertificateChainRequest                                           |   0x02 |
| * CSRRequest                                                        |   0x04 |
| * AddNOC                                                            |   0x06 |
| * UpdateNOC                                                         |   0x07 |
| * UpdateFabricLabel                                                 |   0x09 |
| * RemoveFabric                                                      |   0x0A |
| * AddTrustedRootCertificate                                         |   0x0B |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * NOCs                                                              | 0x0000 |
| * Fabrics                                                           | 0x0001 |
| * SupportedFabrics                                                  | 0x0002 |
| * CommissionedFabrics                                               | 0x0003 |
| * TrustedRootCertificates                                           | 0x0004 |
| * CurrentFabricIndex                                                | 0x0005 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command AttestationRequest
 */
class OperationalCredentialsAttestationRequest : public ClusterCommand
{
public:
    OperationalCredentialsAttestationRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("attestation-request", credsIssuerConfig)
    {
        AddArgument("AttestationNonce", &mRequest.attestationNonce);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OperationalCredentials::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OperationalCredentials::Commands::AttestationRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OperationalCredentials::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OperationalCredentials::Commands::AttestationRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::OperationalCredentials::Commands::AttestationRequest::Type mRequest;
};

/*
 * Command CertificateChainRequest
 */
class OperationalCredentialsCertificateChainRequest : public ClusterCommand
{
public:
    OperationalCredentialsCertificateChainRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("certificate-chain-request", credsIssuerConfig)
    {
        AddArgument("CertificateType", 0, UINT8_MAX, &mRequest.certificateType);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OperationalCredentials::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OperationalCredentials::Commands::CertificateChainRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OperationalCredentials::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OperationalCredentials::Commands::CertificateChainRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::OperationalCredentials::Commands::CertificateChainRequest::Type mRequest;
};

/*
 * Command CSRRequest
 */
class OperationalCredentialsCSRRequest : public ClusterCommand
{
public:
    OperationalCredentialsCSRRequest(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("csrrequest", credsIssuerConfig)
    {
        AddArgument("CSRNonce", &mRequest.CSRNonce);
        AddArgument("IsForUpdateNOC", 0, 1, &mRequest.isForUpdateNOC);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OperationalCredentials::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OperationalCredentials::Commands::CSRRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OperationalCredentials::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OperationalCredentials::Commands::CSRRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::OperationalCredentials::Commands::CSRRequest::Type mRequest;
};

/*
 * Command AddNOC
 */
class OperationalCredentialsAddNOC : public ClusterCommand
{
public:
    OperationalCredentialsAddNOC(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("add-noc", credsIssuerConfig)
    {
        AddArgument("NOCValue", &mRequest.NOCValue);
        AddArgument("ICACValue", &mRequest.ICACValue);
        AddArgument("IPKValue", &mRequest.IPKValue);
        AddArgument("CaseAdminSubject", 0, UINT64_MAX, &mRequest.caseAdminSubject);
        AddArgument("AdminVendorId", 0, UINT16_MAX, &mRequest.adminVendorId);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OperationalCredentials::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OperationalCredentials::Commands::AddNOC::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OperationalCredentials::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OperationalCredentials::Commands::AddNOC::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::OperationalCredentials::Commands::AddNOC::Type mRequest;
};

/*
 * Command UpdateNOC
 */
class OperationalCredentialsUpdateNOC : public ClusterCommand
{
public:
    OperationalCredentialsUpdateNOC(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("update-noc", credsIssuerConfig)
    {
        AddArgument("NOCValue", &mRequest.NOCValue);
        AddArgument("ICACValue", &mRequest.ICACValue);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OperationalCredentials::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OperationalCredentials::Commands::UpdateNOC::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OperationalCredentials::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OperationalCredentials::Commands::UpdateNOC::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::OperationalCredentials::Commands::UpdateNOC::Type mRequest;
};

/*
 * Command UpdateFabricLabel
 */
class OperationalCredentialsUpdateFabricLabel : public ClusterCommand
{
public:
    OperationalCredentialsUpdateFabricLabel(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("update-fabric-label", credsIssuerConfig)
    {
        AddArgument("Label", &mRequest.label);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OperationalCredentials::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OperationalCredentials::Commands::UpdateFabricLabel::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OperationalCredentials::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OperationalCredentials::Commands::UpdateFabricLabel::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::OperationalCredentials::Commands::UpdateFabricLabel::Type mRequest;
};

/*
 * Command RemoveFabric
 */
class OperationalCredentialsRemoveFabric : public ClusterCommand
{
public:
    OperationalCredentialsRemoveFabric(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("remove-fabric", credsIssuerConfig)
    {
        AddArgument("FabricIndex", 0, UINT8_MAX, &mRequest.fabricIndex);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OperationalCredentials::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OperationalCredentials::Commands::RemoveFabric::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OperationalCredentials::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OperationalCredentials::Commands::RemoveFabric::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::OperationalCredentials::Commands::RemoveFabric::Type mRequest;
};

/*
 * Command AddTrustedRootCertificate
 */
class OperationalCredentialsAddTrustedRootCertificate : public ClusterCommand
{
public:
    OperationalCredentialsAddTrustedRootCertificate(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("add-trusted-root-certificate", credsIssuerConfig)
    {
        AddArgument("RootCACertificate", &mRequest.rootCACertificate);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OperationalCredentials::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OperationalCredentials::Commands::AddTrustedRootCertificate::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OperationalCredentials::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OperationalCredentials::Commands::AddTrustedRootCertificate::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::OperationalCredentials::Commands::AddTrustedRootCertificate::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster GroupKeyManagement                                          | 0x003F |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * KeySetWrite                                                       |   0x00 |
| * KeySetRead                                                        |   0x01 |
| * KeySetRemove                                                      |   0x03 |
| * KeySetReadAllIndices                                              |   0x04 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * GroupKeyMap                                                       | 0x0000 |
| * GroupTable                                                        | 0x0001 |
| * MaxGroupsPerFabric                                                | 0x0002 |
| * MaxGroupKeysPerFabric                                             | 0x0003 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command KeySetWrite
 */
class GroupKeyManagementKeySetWrite : public ClusterCommand
{
public:
    GroupKeyManagementKeySetWrite(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("key-set-write", credsIssuerConfig), mComplex_GroupKeySet(&mRequest.groupKeySet)
    {
        AddArgument("GroupKeySet", &mComplex_GroupKeySet);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::GroupKeyManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::GroupKeyManagement::Commands::KeySetWrite::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::GroupKeyManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::GroupKeyManagement::Commands::KeySetWrite::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::GroupKeyManagement::Commands::KeySetWrite::Type mRequest;
    TypedComplexArgument<chip::app::Clusters::GroupKeyManagement::Structs::GroupKeySetStruct::Type> mComplex_GroupKeySet;
};

/*
 * Command KeySetRead
 */
class GroupKeyManagementKeySetRead : public ClusterCommand
{
public:
    GroupKeyManagementKeySetRead(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("key-set-read", credsIssuerConfig)
    {
        AddArgument("GroupKeySetID", 0, UINT16_MAX, &mRequest.groupKeySetID);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::GroupKeyManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::GroupKeyManagement::Commands::KeySetRead::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::GroupKeyManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::GroupKeyManagement::Commands::KeySetRead::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::GroupKeyManagement::Commands::KeySetRead::Type mRequest;
};

/*
 * Command KeySetRemove
 */
class GroupKeyManagementKeySetRemove : public ClusterCommand
{
public:
    GroupKeyManagementKeySetRemove(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("key-set-remove", credsIssuerConfig)
    {
        AddArgument("GroupKeySetID", 0, UINT16_MAX, &mRequest.groupKeySetID);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::GroupKeyManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::GroupKeyManagement::Commands::KeySetRemove::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::GroupKeyManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::GroupKeyManagement::Commands::KeySetRemove::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::GroupKeyManagement::Commands::KeySetRemove::Type mRequest;
};

/*
 * Command KeySetReadAllIndices
 */
class GroupKeyManagementKeySetReadAllIndices : public ClusterCommand
{
public:
    GroupKeyManagementKeySetReadAllIndices(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("key-set-read-all-indices", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::GroupKeyManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::GroupKeyManagement::Commands::KeySetReadAllIndices::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::GroupKeyManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::GroupKeyManagement::Commands::KeySetReadAllIndices::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::GroupKeyManagement::Commands::KeySetReadAllIndices::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster FixedLabel                                                  | 0x0040 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * LabelList                                                         | 0x0000 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster UserLabel                                                   | 0x0041 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * LabelList                                                         | 0x0000 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster ProxyConfiguration                                          | 0x0042 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster ProxyDiscovery                                              | 0x0043 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster ProxyValid                                                  | 0x0044 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster BooleanState                                                | 0x0045 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * StateValue                                                        | 0x0000 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * StateChange                                                       | 0x0000 |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster IcdManagement                                               | 0x0046 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * RegisterClient                                                    |   0x00 |
| * UnregisterClient                                                  |   0x02 |
| * StayActiveRequest                                                 |   0x03 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * IdleModeDuration                                                  | 0x0000 |
| * ActiveModeDuration                                                | 0x0001 |
| * ActiveModeThreshold                                               | 0x0002 |
| * RegisteredClients                                                 | 0x0003 |
| * ICDCounter                                                        | 0x0004 |
| * ClientsSupportedPerFabric                                         | 0x0005 |
| * UserActiveModeTriggerHint                                         | 0x0006 |
| * UserActiveModeTriggerInstruction                                  | 0x0007 |
| * OperatingMode                                                     | 0x0008 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command RegisterClient
 */
class IcdManagementRegisterClient : public ClusterCommand
{
public:
    IcdManagementRegisterClient(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("register-client", credsIssuerConfig)
    {
        AddArgument("CheckInNodeID", 0, UINT64_MAX, &mRequest.checkInNodeID);
        AddArgument("MonitoredSubject", 0, UINT64_MAX, &mRequest.monitoredSubject);
        AddArgument("Key", &mRequest.key);
        AddArgument("VerificationKey", &mRequest.verificationKey);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::IcdManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::IcdManagement::Commands::RegisterClient::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::IcdManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::IcdManagement::Commands::RegisterClient::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::IcdManagement::Commands::RegisterClient::Type mRequest;
};

/*
 * Command UnregisterClient
 */
class IcdManagementUnregisterClient : public ClusterCommand
{
public:
    IcdManagementUnregisterClient(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("unregister-client", credsIssuerConfig)
    {
        AddArgument("CheckInNodeID", 0, UINT64_MAX, &mRequest.checkInNodeID);
        AddArgument("VerificationKey", &mRequest.verificationKey);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::IcdManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::IcdManagement::Commands::UnregisterClient::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::IcdManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::IcdManagement::Commands::UnregisterClient::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::IcdManagement::Commands::UnregisterClient::Type mRequest;
};

/*
 * Command StayActiveRequest
 */
class IcdManagementStayActiveRequest : public ClusterCommand
{
public:
    IcdManagementStayActiveRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("stay-active-request", credsIssuerConfig)
    {
        AddArgument("StayActiveDuration", 0, UINT32_MAX, &mRequest.stayActiveDuration);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::IcdManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::IcdManagement::Commands::StayActiveRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::IcdManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::IcdManagement::Commands::StayActiveRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::IcdManagement::Commands::StayActiveRequest::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster Timer                                                       | 0x0047 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * SetTimer                                                          |   0x00 |
| * ResetTimer                                                        |   0x01 |
| * AddTime                                                           |   0x02 |
| * ReduceTime                                                        |   0x03 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * SetTime                                                           | 0x0000 |
| * TimeRemaining                                                     | 0x0001 |
| * TimerState                                                        | 0x0002 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command SetTimer
 */
class TimerSetTimer : public ClusterCommand
{
public:
    TimerSetTimer(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("set-timer", credsIssuerConfig)
    {
        AddArgument("NewTime", 0, UINT32_MAX, &mRequest.newTime);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Timer::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Timer::Commands::SetTimer::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Timer::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Timer::Commands::SetTimer::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Timer::Commands::SetTimer::Type mRequest;
};

/*
 * Command ResetTimer
 */
class TimerResetTimer : public ClusterCommand
{
public:
    TimerResetTimer(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("reset-timer", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Timer::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Timer::Commands::ResetTimer::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Timer::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Timer::Commands::ResetTimer::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Timer::Commands::ResetTimer::Type mRequest;
};

/*
 * Command AddTime
 */
class TimerAddTime : public ClusterCommand
{
public:
    TimerAddTime(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("add-time", credsIssuerConfig)
    {
        AddArgument("AdditionalTime", 0, UINT32_MAX, &mRequest.additionalTime);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Timer::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Timer::Commands::AddTime::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Timer::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Timer::Commands::AddTime::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Timer::Commands::AddTime::Type mRequest;
};

/*
 * Command ReduceTime
 */
class TimerReduceTime : public ClusterCommand
{
public:
    TimerReduceTime(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("reduce-time", credsIssuerConfig)
    {
        AddArgument("TimeReduction", 0, UINT32_MAX, &mRequest.timeReduction);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Timer::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Timer::Commands::ReduceTime::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Timer::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Timer::Commands::ReduceTime::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Timer::Commands::ReduceTime::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster OvenCavityOperationalState                                  | 0x0048 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * Pause                                                             |   0x00 |
| * Stop                                                              |   0x01 |
| * Start                                                             |   0x02 |
| * Resume                                                            |   0x03 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * PhaseList                                                         | 0x0000 |
| * CurrentPhase                                                      | 0x0001 |
| * CountdownTime                                                     | 0x0002 |
| * OperationalStateList                                              | 0x0003 |
| * OperationalState                                                  | 0x0004 |
| * OperationalError                                                  | 0x0005 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * OperationalError                                                  | 0x0000 |
| * OperationCompletion                                               | 0x0001 |
\*----------------------------------------------------------------------------*/

/*
 * Command Pause
 */
class OvenCavityOperationalStatePause : public ClusterCommand
{
public:
    OvenCavityOperationalStatePause(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("pause", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OvenCavityOperationalState::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OvenCavityOperationalState::Commands::Pause::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OvenCavityOperationalState::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OvenCavityOperationalState::Commands::Pause::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::OvenCavityOperationalState::Commands::Pause::Type mRequest;
};

/*
 * Command Stop
 */
class OvenCavityOperationalStateStop : public ClusterCommand
{
public:
    OvenCavityOperationalStateStop(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("stop", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OvenCavityOperationalState::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OvenCavityOperationalState::Commands::Stop::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OvenCavityOperationalState::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OvenCavityOperationalState::Commands::Stop::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::OvenCavityOperationalState::Commands::Stop::Type mRequest;
};

/*
 * Command Start
 */
class OvenCavityOperationalStateStart : public ClusterCommand
{
public:
    OvenCavityOperationalStateStart(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("start", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OvenCavityOperationalState::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OvenCavityOperationalState::Commands::Start::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OvenCavityOperationalState::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OvenCavityOperationalState::Commands::Start::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::OvenCavityOperationalState::Commands::Start::Type mRequest;
};

/*
 * Command Resume
 */
class OvenCavityOperationalStateResume : public ClusterCommand
{
public:
    OvenCavityOperationalStateResume(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("resume", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OvenCavityOperationalState::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OvenCavityOperationalState::Commands::Resume::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OvenCavityOperationalState::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OvenCavityOperationalState::Commands::Resume::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::OvenCavityOperationalState::Commands::Resume::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster OvenMode                                                    | 0x0049 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * ChangeToMode                                                      |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * SupportedModes                                                    | 0x0000 |
| * CurrentMode                                                       | 0x0001 |
| * StartUpMode                                                       | 0x0002 |
| * OnMode                                                            | 0x0003 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command ChangeToMode
 */
class OvenModeChangeToMode : public ClusterCommand
{
public:
    OvenModeChangeToMode(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("change-to-mode", credsIssuerConfig)
    {
        AddArgument("NewMode", 0, UINT8_MAX, &mRequest.newMode);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OvenMode::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OvenMode::Commands::ChangeToMode::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OvenMode::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OvenMode::Commands::ChangeToMode::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::OvenMode::Commands::ChangeToMode::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster LaundryDryerControls                                        | 0x004A |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * SupportedDrynessLevels                                            | 0x0000 |
| * SelectedDrynessLevel                                              | 0x0001 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster ModeSelect                                                  | 0x0050 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * ChangeToMode                                                      |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * Description                                                       | 0x0000 |
| * StandardNamespace                                                 | 0x0001 |
| * SupportedModes                                                    | 0x0002 |
| * CurrentMode                                                       | 0x0003 |
| * StartUpMode                                                       | 0x0004 |
| * OnMode                                                            | 0x0005 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command ChangeToMode
 */
class ModeSelectChangeToMode : public ClusterCommand
{
public:
    ModeSelectChangeToMode(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("change-to-mode", credsIssuerConfig)
    {
        AddArgument("NewMode", 0, UINT8_MAX, &mRequest.newMode);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ModeSelect::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ModeSelect::Commands::ChangeToMode::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ModeSelect::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ModeSelect::Commands::ChangeToMode::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ModeSelect::Commands::ChangeToMode::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster LaundryWasherMode                                           | 0x0051 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * ChangeToMode                                                      |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * SupportedModes                                                    | 0x0000 |
| * CurrentMode                                                       | 0x0001 |
| * StartUpMode                                                       | 0x0002 |
| * OnMode                                                            | 0x0003 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command ChangeToMode
 */
class LaundryWasherModeChangeToMode : public ClusterCommand
{
public:
    LaundryWasherModeChangeToMode(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("change-to-mode", credsIssuerConfig)
    {
        AddArgument("NewMode", 0, UINT8_MAX, &mRequest.newMode);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::LaundryWasherMode::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::LaundryWasherMode::Commands::ChangeToMode::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::LaundryWasherMode::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::LaundryWasherMode::Commands::ChangeToMode::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::LaundryWasherMode::Commands::ChangeToMode::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster RefrigeratorAndTemperatureControlledCabinetMode             | 0x0052 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * ChangeToMode                                                      |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * SupportedModes                                                    | 0x0000 |
| * CurrentMode                                                       | 0x0001 |
| * StartUpMode                                                       | 0x0002 |
| * OnMode                                                            | 0x0003 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command ChangeToMode
 */
class RefrigeratorAndTemperatureControlledCabinetModeChangeToMode : public ClusterCommand
{
public:
    RefrigeratorAndTemperatureControlledCabinetModeChangeToMode(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("change-to-mode", credsIssuerConfig)
    {
        AddArgument("NewMode", 0, UINT8_MAX, &mRequest.newMode);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Id;
        constexpr chip::CommandId commandId =
            chip::app::Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Commands::ChangeToMode::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Id;
        constexpr chip::CommandId commandId =
            chip::app::Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Commands::ChangeToMode::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Commands::ChangeToMode::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster LaundryWasherControls                                       | 0x0053 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * SpinSpeeds                                                        | 0x0000 |
| * SpinSpeedCurrent                                                  | 0x0001 |
| * NumberOfRinses                                                    | 0x0002 |
| * SupportedRinses                                                   | 0x0003 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster RvcRunMode                                                  | 0x0054 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * ChangeToMode                                                      |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * SupportedModes                                                    | 0x0000 |
| * CurrentMode                                                       | 0x0001 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command ChangeToMode
 */
class RvcRunModeChangeToMode : public ClusterCommand
{
public:
    RvcRunModeChangeToMode(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("change-to-mode", credsIssuerConfig)
    {
        AddArgument("NewMode", 0, UINT8_MAX, &mRequest.newMode);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::RvcRunMode::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::RvcRunMode::Commands::ChangeToMode::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::RvcRunMode::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::RvcRunMode::Commands::ChangeToMode::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::RvcRunMode::Commands::ChangeToMode::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster RvcCleanMode                                                | 0x0055 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * ChangeToMode                                                      |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * SupportedModes                                                    | 0x0000 |
| * CurrentMode                                                       | 0x0001 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command ChangeToMode
 */
class RvcCleanModeChangeToMode : public ClusterCommand
{
public:
    RvcCleanModeChangeToMode(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("change-to-mode", credsIssuerConfig)
    {
        AddArgument("NewMode", 0, UINT8_MAX, &mRequest.newMode);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::RvcCleanMode::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::RvcCleanMode::Commands::ChangeToMode::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::RvcCleanMode::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::RvcCleanMode::Commands::ChangeToMode::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::RvcCleanMode::Commands::ChangeToMode::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster TemperatureControl                                          | 0x0056 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * SetTemperature                                                    |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * TemperatureSetpoint                                               | 0x0000 |
| * MinTemperature                                                    | 0x0001 |
| * MaxTemperature                                                    | 0x0002 |
| * Step                                                              | 0x0003 |
| * SelectedTemperatureLevel                                          | 0x0004 |
| * SupportedTemperatureLevels                                        | 0x0005 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command SetTemperature
 */
class TemperatureControlSetTemperature : public ClusterCommand
{
public:
    TemperatureControlSetTemperature(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("set-temperature", credsIssuerConfig)
    {
        AddArgument("TargetTemperature", INT16_MIN, INT16_MAX, &mRequest.targetTemperature);
        AddArgument("TargetTemperatureLevel", 0, UINT8_MAX, &mRequest.targetTemperatureLevel);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::TemperatureControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::TemperatureControl::Commands::SetTemperature::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::TemperatureControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::TemperatureControl::Commands::SetTemperature::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::TemperatureControl::Commands::SetTemperature::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster RefrigeratorAlarm                                           | 0x0057 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * Mask                                                              | 0x0000 |
| * State                                                             | 0x0002 |
| * Supported                                                         | 0x0003 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * Notify                                                            | 0x0000 |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster DishwasherMode                                              | 0x0059 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * ChangeToMode                                                      |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * SupportedModes                                                    | 0x0000 |
| * CurrentMode                                                       | 0x0001 |
| * StartUpMode                                                       | 0x0002 |
| * OnMode                                                            | 0x0003 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command ChangeToMode
 */
class DishwasherModeChangeToMode : public ClusterCommand
{
public:
    DishwasherModeChangeToMode(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("change-to-mode", credsIssuerConfig)
    {
        AddArgument("NewMode", 0, UINT8_MAX, &mRequest.newMode);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DishwasherMode::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DishwasherMode::Commands::ChangeToMode::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DishwasherMode::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DishwasherMode::Commands::ChangeToMode::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DishwasherMode::Commands::ChangeToMode::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster AirQuality                                                  | 0x005B |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * AirQuality                                                        | 0x0000 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster SmokeCoAlarm                                                | 0x005C |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * SelfTestRequest                                                   |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * ExpressedState                                                    | 0x0000 |
| * SmokeState                                                        | 0x0001 |
| * COState                                                           | 0x0002 |
| * BatteryAlert                                                      | 0x0003 |
| * DeviceMuted                                                       | 0x0004 |
| * TestInProgress                                                    | 0x0005 |
| * HardwareFaultAlert                                                | 0x0006 |
| * EndOfServiceAlert                                                 | 0x0007 |
| * InterconnectSmokeAlarm                                            | 0x0008 |
| * InterconnectCOAlarm                                               | 0x0009 |
| * ContaminationState                                                | 0x000A |
| * SmokeSensitivityLevel                                             | 0x000B |
| * ExpiryDate                                                        | 0x000C |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * SmokeAlarm                                                        | 0x0000 |
| * COAlarm                                                           | 0x0001 |
| * LowBattery                                                        | 0x0002 |
| * HardwareFault                                                     | 0x0003 |
| * EndOfService                                                      | 0x0004 |
| * SelfTestComplete                                                  | 0x0005 |
| * AlarmMuted                                                        | 0x0006 |
| * MuteEnded                                                         | 0x0007 |
| * InterconnectSmokeAlarm                                            | 0x0008 |
| * InterconnectCOAlarm                                               | 0x0009 |
| * AllClear                                                          | 0x000A |
\*----------------------------------------------------------------------------*/

/*
 * Command SelfTestRequest
 */
class SmokeCoAlarmSelfTestRequest : public ClusterCommand
{
public:
    SmokeCoAlarmSelfTestRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("self-test-request", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::SmokeCoAlarm::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::SmokeCoAlarm::Commands::SelfTestRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::SmokeCoAlarm::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::SmokeCoAlarm::Commands::SelfTestRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::SmokeCoAlarm::Commands::SelfTestRequest::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster DishwasherAlarm                                             | 0x005D |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * Reset                                                             |   0x00 |
| * ModifyEnabledAlarms                                               |   0x01 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * Mask                                                              | 0x0000 |
| * Latch                                                             | 0x0001 |
| * State                                                             | 0x0002 |
| * Supported                                                         | 0x0003 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * Notify                                                            | 0x0000 |
\*----------------------------------------------------------------------------*/

/*
 * Command Reset
 */
class DishwasherAlarmReset : public ClusterCommand
{
public:
    DishwasherAlarmReset(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("reset", credsIssuerConfig)
    {
        AddArgument("Alarms", 0, UINT32_MAX, &mRequest.alarms);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DishwasherAlarm::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DishwasherAlarm::Commands::Reset::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DishwasherAlarm::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DishwasherAlarm::Commands::Reset::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DishwasherAlarm::Commands::Reset::Type mRequest;
};

/*
 * Command ModifyEnabledAlarms
 */
class DishwasherAlarmModifyEnabledAlarms : public ClusterCommand
{
public:
    DishwasherAlarmModifyEnabledAlarms(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("modify-enabled-alarms", credsIssuerConfig)
    {
        AddArgument("Mask", 0, UINT32_MAX, &mRequest.mask);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DishwasherAlarm::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DishwasherAlarm::Commands::ModifyEnabledAlarms::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DishwasherAlarm::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DishwasherAlarm::Commands::ModifyEnabledAlarms::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DishwasherAlarm::Commands::ModifyEnabledAlarms::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster MicrowaveOvenMode                                           | 0x005E |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * SupportedModes                                                    | 0x0000 |
| * CurrentMode                                                       | 0x0001 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster MicrowaveOvenControl                                        | 0x005F |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * SetCookingParameters                                              |   0x00 |
| * AddMoreTime                                                       |   0x01 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * CookTime                                                          | 0x0000 |
| * MaxCookTime                                                       | 0x0001 |
| * PowerSetting                                                      | 0x0002 |
| * MinPower                                                          | 0x0003 |
| * MaxPower                                                          | 0x0004 |
| * PowerStep                                                         | 0x0005 |
| * SupportedWatts                                                    | 0x0006 |
| * SelectedWattIndex                                                 | 0x0007 |
| * WattRating                                                        | 0x0008 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command SetCookingParameters
 */
class MicrowaveOvenControlSetCookingParameters : public ClusterCommand
{
public:
    MicrowaveOvenControlSetCookingParameters(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("set-cooking-parameters", credsIssuerConfig)
    {
        AddArgument("CookMode", 0, UINT8_MAX, &mRequest.cookMode);
        AddArgument("CookTime", 0, UINT32_MAX, &mRequest.cookTime);
        AddArgument("PowerSetting", 0, UINT8_MAX, &mRequest.powerSetting);
        AddArgument("WattSettingIndex", 0, UINT8_MAX, &mRequest.wattSettingIndex);
        AddArgument("StartAfterSetting", 0, 1, &mRequest.startAfterSetting);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MicrowaveOvenControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MicrowaveOvenControl::Commands::SetCookingParameters::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MicrowaveOvenControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MicrowaveOvenControl::Commands::SetCookingParameters::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::MicrowaveOvenControl::Commands::SetCookingParameters::Type mRequest;
};

/*
 * Command AddMoreTime
 */
class MicrowaveOvenControlAddMoreTime : public ClusterCommand
{
public:
    MicrowaveOvenControlAddMoreTime(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("add-more-time", credsIssuerConfig)
    {
        AddArgument("TimeToAdd", 0, UINT32_MAX, &mRequest.timeToAdd);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MicrowaveOvenControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MicrowaveOvenControl::Commands::AddMoreTime::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MicrowaveOvenControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MicrowaveOvenControl::Commands::AddMoreTime::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::MicrowaveOvenControl::Commands::AddMoreTime::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster OperationalState                                            | 0x0060 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * Pause                                                             |   0x00 |
| * Stop                                                              |   0x01 |
| * Start                                                             |   0x02 |
| * Resume                                                            |   0x03 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * PhaseList                                                         | 0x0000 |
| * CurrentPhase                                                      | 0x0001 |
| * CountdownTime                                                     | 0x0002 |
| * OperationalStateList                                              | 0x0003 |
| * OperationalState                                                  | 0x0004 |
| * OperationalError                                                  | 0x0005 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * OperationalError                                                  | 0x0000 |
| * OperationCompletion                                               | 0x0001 |
\*----------------------------------------------------------------------------*/

/*
 * Command Pause
 */
class OperationalStatePause : public ClusterCommand
{
public:
    OperationalStatePause(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("pause", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OperationalState::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OperationalState::Commands::Pause::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OperationalState::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OperationalState::Commands::Pause::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::OperationalState::Commands::Pause::Type mRequest;
};

/*
 * Command Stop
 */
class OperationalStateStop : public ClusterCommand
{
public:
    OperationalStateStop(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("stop", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OperationalState::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OperationalState::Commands::Stop::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OperationalState::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OperationalState::Commands::Stop::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::OperationalState::Commands::Stop::Type mRequest;
};

/*
 * Command Start
 */
class OperationalStateStart : public ClusterCommand
{
public:
    OperationalStateStart(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("start", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OperationalState::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OperationalState::Commands::Start::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OperationalState::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OperationalState::Commands::Start::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::OperationalState::Commands::Start::Type mRequest;
};

/*
 * Command Resume
 */
class OperationalStateResume : public ClusterCommand
{
public:
    OperationalStateResume(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("resume", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OperationalState::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OperationalState::Commands::Resume::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::OperationalState::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::OperationalState::Commands::Resume::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::OperationalState::Commands::Resume::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster RvcOperationalState                                         | 0x0061 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * Pause                                                             |   0x00 |
| * Resume                                                            |   0x03 |
| * GoHome                                                            |   0x80 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * PhaseList                                                         | 0x0000 |
| * CurrentPhase                                                      | 0x0001 |
| * CountdownTime                                                     | 0x0002 |
| * OperationalStateList                                              | 0x0003 |
| * OperationalState                                                  | 0x0004 |
| * OperationalError                                                  | 0x0005 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * OperationalError                                                  | 0x0000 |
| * OperationCompletion                                               | 0x0001 |
\*----------------------------------------------------------------------------*/

/*
 * Command Pause
 */
class RvcOperationalStatePause : public ClusterCommand
{
public:
    RvcOperationalStatePause(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("pause", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::RvcOperationalState::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::RvcOperationalState::Commands::Pause::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::RvcOperationalState::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::RvcOperationalState::Commands::Pause::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::RvcOperationalState::Commands::Pause::Type mRequest;
};

/*
 * Command Resume
 */
class RvcOperationalStateResume : public ClusterCommand
{
public:
    RvcOperationalStateResume(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("resume", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::RvcOperationalState::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::RvcOperationalState::Commands::Resume::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::RvcOperationalState::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::RvcOperationalState::Commands::Resume::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::RvcOperationalState::Commands::Resume::Type mRequest;
};

/*
 * Command GoHome
 */
class RvcOperationalStateGoHome : public ClusterCommand
{
public:
    RvcOperationalStateGoHome(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("go-home", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::RvcOperationalState::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::RvcOperationalState::Commands::GoHome::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::RvcOperationalState::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::RvcOperationalState::Commands::GoHome::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::RvcOperationalState::Commands::GoHome::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster ScenesManagement                                            | 0x0062 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * AddScene                                                          |   0x00 |
| * ViewScene                                                         |   0x01 |
| * RemoveScene                                                       |   0x02 |
| * RemoveAllScenes                                                   |   0x03 |
| * StoreScene                                                        |   0x04 |
| * RecallScene                                                       |   0x05 |
| * GetSceneMembership                                                |   0x06 |
| * CopyScene                                                         |   0x40 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * LastConfiguredBy                                                  | 0x0000 |
| * SceneTableSize                                                    | 0x0001 |
| * FabricSceneInfo                                                   | 0x0002 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command AddScene
 */
class ScenesManagementAddScene : public ClusterCommand
{
public:
    ScenesManagementAddScene(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("add-scene", credsIssuerConfig), mComplex_ExtensionFieldSets(&mRequest.extensionFieldSets)
    {
        AddArgument("GroupID", 0, UINT16_MAX, &mRequest.groupID);
        AddArgument("SceneID", 0, UINT8_MAX, &mRequest.sceneID);
        AddArgument("TransitionTime", 0, UINT32_MAX, &mRequest.transitionTime);
        AddArgument("SceneName", &mRequest.sceneName);
        AddArgument("ExtensionFieldSets", &mComplex_ExtensionFieldSets);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ScenesManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ScenesManagement::Commands::AddScene::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ScenesManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ScenesManagement::Commands::AddScene::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ScenesManagement::Commands::AddScene::Type mRequest;
    TypedComplexArgument<chip::app::DataModel::List<const chip::app::Clusters::ScenesManagement::Structs::ExtensionFieldSet::Type>>
        mComplex_ExtensionFieldSets;
};

/*
 * Command ViewScene
 */
class ScenesManagementViewScene : public ClusterCommand
{
public:
    ScenesManagementViewScene(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("view-scene", credsIssuerConfig)
    {
        AddArgument("GroupID", 0, UINT16_MAX, &mRequest.groupID);
        AddArgument("SceneID", 0, UINT8_MAX, &mRequest.sceneID);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ScenesManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ScenesManagement::Commands::ViewScene::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ScenesManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ScenesManagement::Commands::ViewScene::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ScenesManagement::Commands::ViewScene::Type mRequest;
};

/*
 * Command RemoveScene
 */
class ScenesManagementRemoveScene : public ClusterCommand
{
public:
    ScenesManagementRemoveScene(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("remove-scene", credsIssuerConfig)
    {
        AddArgument("GroupID", 0, UINT16_MAX, &mRequest.groupID);
        AddArgument("SceneID", 0, UINT8_MAX, &mRequest.sceneID);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ScenesManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ScenesManagement::Commands::RemoveScene::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ScenesManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ScenesManagement::Commands::RemoveScene::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ScenesManagement::Commands::RemoveScene::Type mRequest;
};

/*
 * Command RemoveAllScenes
 */
class ScenesManagementRemoveAllScenes : public ClusterCommand
{
public:
    ScenesManagementRemoveAllScenes(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("remove-all-scenes", credsIssuerConfig)
    {
        AddArgument("GroupID", 0, UINT16_MAX, &mRequest.groupID);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ScenesManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ScenesManagement::Commands::RemoveAllScenes::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ScenesManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ScenesManagement::Commands::RemoveAllScenes::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ScenesManagement::Commands::RemoveAllScenes::Type mRequest;
};

/*
 * Command StoreScene
 */
class ScenesManagementStoreScene : public ClusterCommand
{
public:
    ScenesManagementStoreScene(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("store-scene", credsIssuerConfig)
    {
        AddArgument("GroupID", 0, UINT16_MAX, &mRequest.groupID);
        AddArgument("SceneID", 0, UINT8_MAX, &mRequest.sceneID);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ScenesManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ScenesManagement::Commands::StoreScene::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ScenesManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ScenesManagement::Commands::StoreScene::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ScenesManagement::Commands::StoreScene::Type mRequest;
};

/*
 * Command RecallScene
 */
class ScenesManagementRecallScene : public ClusterCommand
{
public:
    ScenesManagementRecallScene(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("recall-scene", credsIssuerConfig)
    {
        AddArgument("GroupID", 0, UINT16_MAX, &mRequest.groupID);
        AddArgument("SceneID", 0, UINT8_MAX, &mRequest.sceneID);
        AddArgument("TransitionTime", 0, UINT32_MAX, &mRequest.transitionTime);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ScenesManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ScenesManagement::Commands::RecallScene::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ScenesManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ScenesManagement::Commands::RecallScene::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ScenesManagement::Commands::RecallScene::Type mRequest;
};

/*
 * Command GetSceneMembership
 */
class ScenesManagementGetSceneMembership : public ClusterCommand
{
public:
    ScenesManagementGetSceneMembership(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("get-scene-membership", credsIssuerConfig)
    {
        AddArgument("GroupID", 0, UINT16_MAX, &mRequest.groupID);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ScenesManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ScenesManagement::Commands::GetSceneMembership::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ScenesManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ScenesManagement::Commands::GetSceneMembership::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ScenesManagement::Commands::GetSceneMembership::Type mRequest;
};

/*
 * Command CopyScene
 */
class ScenesManagementCopyScene : public ClusterCommand
{
public:
    ScenesManagementCopyScene(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("copy-scene", credsIssuerConfig)
    {
        AddArgument("Mode", 0, UINT8_MAX, &mRequest.mode);
        AddArgument("GroupIdentifierFrom", 0, UINT16_MAX, &mRequest.groupIdentifierFrom);
        AddArgument("SceneIdentifierFrom", 0, UINT8_MAX, &mRequest.sceneIdentifierFrom);
        AddArgument("GroupIdentifierTo", 0, UINT16_MAX, &mRequest.groupIdentifierTo);
        AddArgument("SceneIdentifierTo", 0, UINT8_MAX, &mRequest.sceneIdentifierTo);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ScenesManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ScenesManagement::Commands::CopyScene::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ScenesManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ScenesManagement::Commands::CopyScene::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ScenesManagement::Commands::CopyScene::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster HepaFilterMonitoring                                        | 0x0071 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * ResetCondition                                                    |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * Condition                                                         | 0x0000 |
| * DegradationDirection                                              | 0x0001 |
| * ChangeIndication                                                  | 0x0002 |
| * InPlaceIndicator                                                  | 0x0003 |
| * LastChangedTime                                                   | 0x0004 |
| * ReplacementProductList                                            | 0x0005 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command ResetCondition
 */
class HepaFilterMonitoringResetCondition : public ClusterCommand
{
public:
    HepaFilterMonitoringResetCondition(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("reset-condition", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::HepaFilterMonitoring::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::HepaFilterMonitoring::Commands::ResetCondition::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::HepaFilterMonitoring::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::HepaFilterMonitoring::Commands::ResetCondition::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::HepaFilterMonitoring::Commands::ResetCondition::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster ActivatedCarbonFilterMonitoring                             | 0x0072 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * ResetCondition                                                    |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * Condition                                                         | 0x0000 |
| * DegradationDirection                                              | 0x0001 |
| * ChangeIndication                                                  | 0x0002 |
| * InPlaceIndicator                                                  | 0x0003 |
| * LastChangedTime                                                   | 0x0004 |
| * ReplacementProductList                                            | 0x0005 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command ResetCondition
 */
class ActivatedCarbonFilterMonitoringResetCondition : public ClusterCommand
{
public:
    ActivatedCarbonFilterMonitoringResetCondition(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("reset-condition", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ActivatedCarbonFilterMonitoring::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ActivatedCarbonFilterMonitoring::Commands::ResetCondition::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ActivatedCarbonFilterMonitoring::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ActivatedCarbonFilterMonitoring::Commands::ResetCondition::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ActivatedCarbonFilterMonitoring::Commands::ResetCondition::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster BooleanStateConfiguration                                   | 0x0080 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * SuppressAlarm                                                     |   0x00 |
| * EnableDisableAlarm                                                |   0x01 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * CurrentSensitivityLevel                                           | 0x0000 |
| * SupportedSensitivityLevels                                        | 0x0001 |
| * DefaultSensitivityLevel                                           | 0x0002 |
| * AlarmsActive                                                      | 0x0003 |
| * AlarmsSuppressed                                                  | 0x0004 |
| * AlarmsEnabled                                                     | 0x0005 |
| * AlarmsSupported                                                   | 0x0006 |
| * SensorFault                                                       | 0x0007 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * AlarmsStateChanged                                                | 0x0000 |
| * SensorFault                                                       | 0x0001 |
\*----------------------------------------------------------------------------*/

/*
 * Command SuppressAlarm
 */
class BooleanStateConfigurationSuppressAlarm : public ClusterCommand
{
public:
    BooleanStateConfigurationSuppressAlarm(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("suppress-alarm", credsIssuerConfig)
    {
        AddArgument("AlarmsToSuppress", 0, UINT8_MAX, &mRequest.alarmsToSuppress);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::BooleanStateConfiguration::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::BooleanStateConfiguration::Commands::SuppressAlarm::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::BooleanStateConfiguration::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::BooleanStateConfiguration::Commands::SuppressAlarm::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::BooleanStateConfiguration::Commands::SuppressAlarm::Type mRequest;
};

/*
 * Command EnableDisableAlarm
 */
class BooleanStateConfigurationEnableDisableAlarm : public ClusterCommand
{
public:
    BooleanStateConfigurationEnableDisableAlarm(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("enable-disable-alarm", credsIssuerConfig)
    {
        AddArgument("AlarmsToEnableDisable", 0, UINT8_MAX, &mRequest.alarmsToEnableDisable);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::BooleanStateConfiguration::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::BooleanStateConfiguration::Commands::EnableDisableAlarm::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::BooleanStateConfiguration::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::BooleanStateConfiguration::Commands::EnableDisableAlarm::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::BooleanStateConfiguration::Commands::EnableDisableAlarm::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster ValveConfigurationAndControl                                | 0x0081 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * Open                                                              |   0x00 |
| * Close                                                             |   0x01 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * OpenDuration                                                      | 0x0000 |
| * DefaultOpenDuration                                               | 0x0001 |
| * AutoCloseTime                                                     | 0x0002 |
| * RemainingDuration                                                 | 0x0003 |
| * CurrentState                                                      | 0x0004 |
| * TargetState                                                       | 0x0005 |
| * CurrentLevel                                                      | 0x0006 |
| * TargetLevel                                                       | 0x0007 |
| * DefaultOpenLevel                                                  | 0x0008 |
| * ValveFault                                                        | 0x0009 |
| * LevelStep                                                         | 0x000A |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * ValveStateChanged                                                 | 0x0000 |
| * ValveFault                                                        | 0x0001 |
\*----------------------------------------------------------------------------*/

/*
 * Command Open
 */
class ValveConfigurationAndControlOpen : public ClusterCommand
{
public:
    ValveConfigurationAndControlOpen(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("open", credsIssuerConfig)
    {
        AddArgument("OpenDuration", 0, UINT32_MAX, &mRequest.openDuration);
        AddArgument("TargetLevel", 0, UINT8_MAX, &mRequest.targetLevel);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ValveConfigurationAndControl::Commands::Open::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ValveConfigurationAndControl::Commands::Open::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ValveConfigurationAndControl::Commands::Open::Type mRequest;
};

/*
 * Command Close
 */
class ValveConfigurationAndControlClose : public ClusterCommand
{
public:
    ValveConfigurationAndControlClose(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("close", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ValveConfigurationAndControl::Commands::Close::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ValveConfigurationAndControl::Commands::Close::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ValveConfigurationAndControl::Commands::Close::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster ElectricalPowerMeasurement                                  | 0x0090 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * PowerMode                                                         | 0x0000 |
| * NumberOfMeasurementTypes                                          | 0x0001 |
| * Accuracy                                                          | 0x0002 |
| * Ranges                                                            | 0x0003 |
| * Voltage                                                           | 0x0004 |
| * ActiveCurrent                                                     | 0x0005 |
| * ReactiveCurrent                                                   | 0x0006 |
| * ApparentCurrent                                                   | 0x0007 |
| * ActivePower                                                       | 0x0008 |
| * ReactivePower                                                     | 0x0009 |
| * ApparentPower                                                     | 0x000A |
| * RMSVoltage                                                        | 0x000B |
| * RMSCurrent                                                        | 0x000C |
| * RMSPower                                                          | 0x000D |
| * Frequency                                                         | 0x000E |
| * HarmonicCurrents                                                  | 0x000F |
| * HarmonicPhases                                                    | 0x0010 |
| * PowerFactor                                                       | 0x0011 |
| * NeutralCurrent                                                    | 0x0012 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * MeasurementPeriodRanges                                           | 0x0000 |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster ElectricalEnergyMeasurement                                 | 0x0091 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * Accuracy                                                          | 0x0000 |
| * CumulativeEnergyImported                                          | 0x0001 |
| * CumulativeEnergyExported                                          | 0x0002 |
| * PeriodicEnergyImported                                            | 0x0003 |
| * PeriodicEnergyExported                                            | 0x0004 |
| * CumulativeEnergyReset                                             | 0x0005 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * CumulativeEnergyMeasured                                          | 0x0000 |
| * PeriodicEnergyMeasured                                            | 0x0001 |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster DemandResponseLoadControl                                   | 0x0096 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * RegisterLoadControlProgramRequest                                 |   0x00 |
| * UnregisterLoadControlProgramRequest                               |   0x01 |
| * AddLoadControlEventRequest                                        |   0x02 |
| * RemoveLoadControlEventRequest                                     |   0x03 |
| * ClearLoadControlEventsRequest                                     |   0x04 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * LoadControlPrograms                                               | 0x0000 |
| * NumberOfLoadControlPrograms                                       | 0x0001 |
| * Events                                                            | 0x0002 |
| * ActiveEvents                                                      | 0x0003 |
| * NumberOfEventsPerProgram                                          | 0x0004 |
| * NumberOfTransitions                                               | 0x0005 |
| * DefaultRandomStart                                                | 0x0006 |
| * DefaultRandomDuration                                             | 0x0007 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * LoadControlEventStatusChange                                      | 0x0000 |
\*----------------------------------------------------------------------------*/

/*
 * Command RegisterLoadControlProgramRequest
 */
class DemandResponseLoadControlRegisterLoadControlProgramRequest : public ClusterCommand
{
public:
    DemandResponseLoadControlRegisterLoadControlProgramRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("register-load-control-program-request", credsIssuerConfig),
        mComplex_LoadControlProgram(&mRequest.loadControlProgram)
    {
        AddArgument("LoadControlProgram", &mComplex_LoadControlProgram);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DemandResponseLoadControl::Id;
        constexpr chip::CommandId commandId =
            chip::app::Clusters::DemandResponseLoadControl::Commands::RegisterLoadControlProgramRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DemandResponseLoadControl::Id;
        constexpr chip::CommandId commandId =
            chip::app::Clusters::DemandResponseLoadControl::Commands::RegisterLoadControlProgramRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DemandResponseLoadControl::Commands::RegisterLoadControlProgramRequest::Type mRequest;
    TypedComplexArgument<chip::app::Clusters::DemandResponseLoadControl::Structs::LoadControlProgramStruct::Type>
        mComplex_LoadControlProgram;
};

/*
 * Command UnregisterLoadControlProgramRequest
 */
class DemandResponseLoadControlUnregisterLoadControlProgramRequest : public ClusterCommand
{
public:
    DemandResponseLoadControlUnregisterLoadControlProgramRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("unregister-load-control-program-request", credsIssuerConfig)
    {
        AddArgument("LoadControlProgramID", &mRequest.loadControlProgramID);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DemandResponseLoadControl::Id;
        constexpr chip::CommandId commandId =
            chip::app::Clusters::DemandResponseLoadControl::Commands::UnregisterLoadControlProgramRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DemandResponseLoadControl::Id;
        constexpr chip::CommandId commandId =
            chip::app::Clusters::DemandResponseLoadControl::Commands::UnregisterLoadControlProgramRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DemandResponseLoadControl::Commands::UnregisterLoadControlProgramRequest::Type mRequest;
};

/*
 * Command AddLoadControlEventRequest
 */
class DemandResponseLoadControlAddLoadControlEventRequest : public ClusterCommand
{
public:
    DemandResponseLoadControlAddLoadControlEventRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("add-load-control-event-request", credsIssuerConfig), mComplex_Event(&mRequest.event)
    {
        AddArgument("Event", &mComplex_Event);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DemandResponseLoadControl::Id;
        constexpr chip::CommandId commandId =
            chip::app::Clusters::DemandResponseLoadControl::Commands::AddLoadControlEventRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DemandResponseLoadControl::Id;
        constexpr chip::CommandId commandId =
            chip::app::Clusters::DemandResponseLoadControl::Commands::AddLoadControlEventRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DemandResponseLoadControl::Commands::AddLoadControlEventRequest::Type mRequest;
    TypedComplexArgument<chip::app::Clusters::DemandResponseLoadControl::Structs::LoadControlEventStruct::Type> mComplex_Event;
};

/*
 * Command RemoveLoadControlEventRequest
 */
class DemandResponseLoadControlRemoveLoadControlEventRequest : public ClusterCommand
{
public:
    DemandResponseLoadControlRemoveLoadControlEventRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("remove-load-control-event-request", credsIssuerConfig)
    {
        AddArgument("EventID", &mRequest.eventID);
        AddArgument("CancelControl", 0, UINT16_MAX, &mRequest.cancelControl);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DemandResponseLoadControl::Id;
        constexpr chip::CommandId commandId =
            chip::app::Clusters::DemandResponseLoadControl::Commands::RemoveLoadControlEventRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DemandResponseLoadControl::Id;
        constexpr chip::CommandId commandId =
            chip::app::Clusters::DemandResponseLoadControl::Commands::RemoveLoadControlEventRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DemandResponseLoadControl::Commands::RemoveLoadControlEventRequest::Type mRequest;
};

/*
 * Command ClearLoadControlEventsRequest
 */
class DemandResponseLoadControlClearLoadControlEventsRequest : public ClusterCommand
{
public:
    DemandResponseLoadControlClearLoadControlEventsRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("clear-load-control-events-request", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DemandResponseLoadControl::Id;
        constexpr chip::CommandId commandId =
            chip::app::Clusters::DemandResponseLoadControl::Commands::ClearLoadControlEventsRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DemandResponseLoadControl::Id;
        constexpr chip::CommandId commandId =
            chip::app::Clusters::DemandResponseLoadControl::Commands::ClearLoadControlEventsRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DemandResponseLoadControl::Commands::ClearLoadControlEventsRequest::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster Messages                                                    | 0x0097 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * PresentMessagesRequest                                            |   0x00 |
| * CancelMessagesRequest                                             |   0x01 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * Messages                                                          | 0x0000 |
| * ActiveMessageIDs                                                  | 0x0001 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * MessageQueued                                                     | 0x0000 |
| * MessagePresented                                                  | 0x0001 |
| * MessageComplete                                                   | 0x0002 |
\*----------------------------------------------------------------------------*/

/*
 * Command PresentMessagesRequest
 */
class MessagesPresentMessagesRequest : public ClusterCommand
{
public:
    MessagesPresentMessagesRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("present-messages-request", credsIssuerConfig), mComplex_Responses(&mRequest.responses)
    {
        AddArgument("MessageID", &mRequest.messageID);
        AddArgument("Priority", 0, UINT8_MAX, &mRequest.priority);
        AddArgument("MessageControl", 0, UINT8_MAX, &mRequest.messageControl);
        AddArgument("StartTime", 0, UINT32_MAX, &mRequest.startTime);
        AddArgument("Duration", 0, UINT64_MAX, &mRequest.duration);
        AddArgument("MessageText", &mRequest.messageText);
        AddArgument("Responses", &mComplex_Responses, "", Argument::kOptional);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Messages::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Messages::Commands::PresentMessagesRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Messages::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Messages::Commands::PresentMessagesRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Messages::Commands::PresentMessagesRequest::Type mRequest;
    TypedComplexArgument<
        chip::Optional<chip::app::DataModel::List<const chip::app::Clusters::Messages::Structs::MessageResponseOptionStruct::Type>>>
        mComplex_Responses;
};

/*
 * Command CancelMessagesRequest
 */
class MessagesCancelMessagesRequest : public ClusterCommand
{
public:
    MessagesCancelMessagesRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("cancel-messages-request", credsIssuerConfig), mComplex_MessageIDs(&mRequest.messageIDs)
    {
        AddArgument("MessageIDs", &mComplex_MessageIDs);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Messages::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Messages::Commands::CancelMessagesRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Messages::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Messages::Commands::CancelMessagesRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Messages::Commands::CancelMessagesRequest::Type mRequest;
    TypedComplexArgument<chip::app::DataModel::List<const chip::ByteSpan>> mComplex_MessageIDs;
};

/*----------------------------------------------------------------------------*\
| Cluster DeviceEnergyManagement                                      | 0x0098 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * PowerAdjustRequest                                                |   0x00 |
| * CancelPowerAdjustRequest                                          |   0x01 |
| * StartTimeAdjustRequest                                            |   0x02 |
| * PauseRequest                                                      |   0x03 |
| * ResumeRequest                                                     |   0x04 |
| * ModifyForecastRequest                                             |   0x05 |
| * RequestConstraintBasedForecast                                    |   0x06 |
| * CancelRequest                                                     |   0x07 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * ESAType                                                           | 0x0000 |
| * ESACanGenerate                                                    | 0x0001 |
| * ESAState                                                          | 0x0002 |
| * AbsMinPower                                                       | 0x0003 |
| * AbsMaxPower                                                       | 0x0004 |
| * PowerAdjustmentCapability                                         | 0x0005 |
| * Forecast                                                          | 0x0006 |
| * OptOutState                                                       | 0x0007 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * PowerAdjustStart                                                  | 0x0000 |
| * PowerAdjustEnd                                                    | 0x0001 |
| * Paused                                                            | 0x0002 |
| * Resumed                                                           | 0x0003 |
\*----------------------------------------------------------------------------*/

/*
 * Command PowerAdjustRequest
 */
class DeviceEnergyManagementPowerAdjustRequest : public ClusterCommand
{
public:
    DeviceEnergyManagementPowerAdjustRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("power-adjust-request", credsIssuerConfig)
    {
        AddArgument("Power", INT64_MIN, INT64_MAX, &mRequest.power);
        AddArgument("Duration", 0, UINT32_MAX, &mRequest.duration);
        AddArgument("Cause", 0, UINT8_MAX, &mRequest.cause);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DeviceEnergyManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DeviceEnergyManagement::Commands::PowerAdjustRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DeviceEnergyManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DeviceEnergyManagement::Commands::PowerAdjustRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DeviceEnergyManagement::Commands::PowerAdjustRequest::Type mRequest;
};

/*
 * Command CancelPowerAdjustRequest
 */
class DeviceEnergyManagementCancelPowerAdjustRequest : public ClusterCommand
{
public:
    DeviceEnergyManagementCancelPowerAdjustRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("cancel-power-adjust-request", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DeviceEnergyManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DeviceEnergyManagement::Commands::CancelPowerAdjustRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DeviceEnergyManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DeviceEnergyManagement::Commands::CancelPowerAdjustRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DeviceEnergyManagement::Commands::CancelPowerAdjustRequest::Type mRequest;
};

/*
 * Command StartTimeAdjustRequest
 */
class DeviceEnergyManagementStartTimeAdjustRequest : public ClusterCommand
{
public:
    DeviceEnergyManagementStartTimeAdjustRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("start-time-adjust-request", credsIssuerConfig)
    {
        AddArgument("RequestedStartTime", 0, UINT32_MAX, &mRequest.requestedStartTime);
        AddArgument("Cause", 0, UINT8_MAX, &mRequest.cause);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DeviceEnergyManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DeviceEnergyManagement::Commands::StartTimeAdjustRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DeviceEnergyManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DeviceEnergyManagement::Commands::StartTimeAdjustRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DeviceEnergyManagement::Commands::StartTimeAdjustRequest::Type mRequest;
};

/*
 * Command PauseRequest
 */
class DeviceEnergyManagementPauseRequest : public ClusterCommand
{
public:
    DeviceEnergyManagementPauseRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("pause-request", credsIssuerConfig)
    {
        AddArgument("Duration", 0, UINT32_MAX, &mRequest.duration);
        AddArgument("Cause", 0, UINT8_MAX, &mRequest.cause);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DeviceEnergyManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DeviceEnergyManagement::Commands::PauseRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DeviceEnergyManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DeviceEnergyManagement::Commands::PauseRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DeviceEnergyManagement::Commands::PauseRequest::Type mRequest;
};

/*
 * Command ResumeRequest
 */
class DeviceEnergyManagementResumeRequest : public ClusterCommand
{
public:
    DeviceEnergyManagementResumeRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("resume-request", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DeviceEnergyManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DeviceEnergyManagement::Commands::ResumeRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DeviceEnergyManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DeviceEnergyManagement::Commands::ResumeRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DeviceEnergyManagement::Commands::ResumeRequest::Type mRequest;
};

/*
 * Command ModifyForecastRequest
 */
class DeviceEnergyManagementModifyForecastRequest : public ClusterCommand
{
public:
    DeviceEnergyManagementModifyForecastRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("modify-forecast-request", credsIssuerConfig), mComplex_SlotAdjustments(&mRequest.slotAdjustments)
    {
        AddArgument("ForecastId", 0, UINT32_MAX, &mRequest.forecastId);
        AddArgument("SlotAdjustments", &mComplex_SlotAdjustments);
        AddArgument("Cause", 0, UINT8_MAX, &mRequest.cause);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DeviceEnergyManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DeviceEnergyManagement::Commands::ModifyForecastRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DeviceEnergyManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DeviceEnergyManagement::Commands::ModifyForecastRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DeviceEnergyManagement::Commands::ModifyForecastRequest::Type mRequest;
    TypedComplexArgument<
        chip::app::DataModel::List<const chip::app::Clusters::DeviceEnergyManagement::Structs::SlotAdjustmentStruct::Type>>
        mComplex_SlotAdjustments;
};

/*
 * Command RequestConstraintBasedForecast
 */
class DeviceEnergyManagementRequestConstraintBasedForecast : public ClusterCommand
{
public:
    DeviceEnergyManagementRequestConstraintBasedForecast(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("request-constraint-based-forecast", credsIssuerConfig), mComplex_Constraints(&mRequest.constraints)
    {
        AddArgument("Constraints", &mComplex_Constraints);
        AddArgument("Cause", 0, UINT8_MAX, &mRequest.cause);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DeviceEnergyManagement::Id;
        constexpr chip::CommandId commandId =
            chip::app::Clusters::DeviceEnergyManagement::Commands::RequestConstraintBasedForecast::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DeviceEnergyManagement::Id;
        constexpr chip::CommandId commandId =
            chip::app::Clusters::DeviceEnergyManagement::Commands::RequestConstraintBasedForecast::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DeviceEnergyManagement::Commands::RequestConstraintBasedForecast::Type mRequest;
    TypedComplexArgument<
        chip::app::DataModel::List<const chip::app::Clusters::DeviceEnergyManagement::Structs::ConstraintsStruct::Type>>
        mComplex_Constraints;
};

/*
 * Command CancelRequest
 */
class DeviceEnergyManagementCancelRequest : public ClusterCommand
{
public:
    DeviceEnergyManagementCancelRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("cancel-request", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DeviceEnergyManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DeviceEnergyManagement::Commands::CancelRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DeviceEnergyManagement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DeviceEnergyManagement::Commands::CancelRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DeviceEnergyManagement::Commands::CancelRequest::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster EnergyEvse                                                  | 0x0099 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * Disable                                                           |   0x01 |
| * EnableCharging                                                    |   0x02 |
| * EnableDischarging                                                 |   0x03 |
| * StartDiagnostics                                                  |   0x04 |
| * SetTargets                                                        |   0x05 |
| * GetTargets                                                        |   0x06 |
| * ClearTargets                                                      |   0x07 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * State                                                             | 0x0000 |
| * SupplyState                                                       | 0x0001 |
| * FaultState                                                        | 0x0002 |
| * ChargingEnabledUntil                                              | 0x0003 |
| * DischargingEnabledUntil                                           | 0x0004 |
| * CircuitCapacity                                                   | 0x0005 |
| * MinimumChargeCurrent                                              | 0x0006 |
| * MaximumChargeCurrent                                              | 0x0007 |
| * MaximumDischargeCurrent                                           | 0x0008 |
| * UserMaximumChargeCurrent                                          | 0x0009 |
| * RandomizationDelayWindow                                          | 0x000A |
| * NextChargeStartTime                                               | 0x0023 |
| * NextChargeTargetTime                                              | 0x0024 |
| * NextChargeRequiredEnergy                                          | 0x0025 |
| * NextChargeTargetSoC                                               | 0x0026 |
| * ApproximateEVEfficiency                                           | 0x0027 |
| * StateOfCharge                                                     | 0x0030 |
| * BatteryCapacity                                                   | 0x0031 |
| * VehicleID                                                         | 0x0032 |
| * SessionID                                                         | 0x0040 |
| * SessionDuration                                                   | 0x0041 |
| * SessionEnergyCharged                                              | 0x0042 |
| * SessionEnergyDischarged                                           | 0x0043 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * EVConnected                                                       | 0x0000 |
| * EVNotDetected                                                     | 0x0001 |
| * EnergyTransferStarted                                             | 0x0002 |
| * EnergyTransferStopped                                             | 0x0003 |
| * Fault                                                             | 0x0004 |
| * Rfid                                                              | 0x0005 |
\*----------------------------------------------------------------------------*/

/*
 * Command Disable
 */
class EnergyEvseDisable : public ClusterCommand
{
public:
    EnergyEvseDisable(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("disable", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyEvse::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::EnergyEvse::Commands::Disable::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyEvse::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::EnergyEvse::Commands::Disable::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::EnergyEvse::Commands::Disable::Type mRequest;
};

/*
 * Command EnableCharging
 */
class EnergyEvseEnableCharging : public ClusterCommand
{
public:
    EnergyEvseEnableCharging(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("enable-charging", credsIssuerConfig)
    {
        AddArgument("ChargingEnabledUntil", 0, UINT32_MAX, &mRequest.chargingEnabledUntil);
        AddArgument("MinimumChargeCurrent", INT64_MIN, INT64_MAX, &mRequest.minimumChargeCurrent);
        AddArgument("MaximumChargeCurrent", INT64_MIN, INT64_MAX, &mRequest.maximumChargeCurrent);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyEvse::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::EnergyEvse::Commands::EnableCharging::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyEvse::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::EnergyEvse::Commands::EnableCharging::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::EnergyEvse::Commands::EnableCharging::Type mRequest;
};

/*
 * Command EnableDischarging
 */
class EnergyEvseEnableDischarging : public ClusterCommand
{
public:
    EnergyEvseEnableDischarging(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("enable-discharging", credsIssuerConfig)
    {
        AddArgument("DischargingEnabledUntil", 0, UINT32_MAX, &mRequest.dischargingEnabledUntil);
        AddArgument("MaximumDischargeCurrent", INT64_MIN, INT64_MAX, &mRequest.maximumDischargeCurrent);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyEvse::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::EnergyEvse::Commands::EnableDischarging::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyEvse::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::EnergyEvse::Commands::EnableDischarging::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::EnergyEvse::Commands::EnableDischarging::Type mRequest;
};

/*
 * Command StartDiagnostics
 */
class EnergyEvseStartDiagnostics : public ClusterCommand
{
public:
    EnergyEvseStartDiagnostics(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("start-diagnostics", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyEvse::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::EnergyEvse::Commands::StartDiagnostics::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyEvse::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::EnergyEvse::Commands::StartDiagnostics::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::EnergyEvse::Commands::StartDiagnostics::Type mRequest;
};

/*
 * Command SetTargets
 */
class EnergyEvseSetTargets : public ClusterCommand
{
public:
    EnergyEvseSetTargets(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("set-targets", credsIssuerConfig), mComplex_ChargingTargetSchedules(&mRequest.chargingTargetSchedules)
    {
        AddArgument("ChargingTargetSchedules", &mComplex_ChargingTargetSchedules);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyEvse::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::EnergyEvse::Commands::SetTargets::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyEvse::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::EnergyEvse::Commands::SetTargets::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::EnergyEvse::Commands::SetTargets::Type mRequest;
    TypedComplexArgument<
        chip::app::DataModel::List<const chip::app::Clusters::EnergyEvse::Structs::ChargingTargetScheduleStruct::Type>>
        mComplex_ChargingTargetSchedules;
};

/*
 * Command GetTargets
 */
class EnergyEvseGetTargets : public ClusterCommand
{
public:
    EnergyEvseGetTargets(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("get-targets", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyEvse::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::EnergyEvse::Commands::GetTargets::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyEvse::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::EnergyEvse::Commands::GetTargets::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::EnergyEvse::Commands::GetTargets::Type mRequest;
};

/*
 * Command ClearTargets
 */
class EnergyEvseClearTargets : public ClusterCommand
{
public:
    EnergyEvseClearTargets(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("clear-targets", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyEvse::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::EnergyEvse::Commands::ClearTargets::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyEvse::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::EnergyEvse::Commands::ClearTargets::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::EnergyEvse::Commands::ClearTargets::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster EnergyPreference                                            | 0x009B |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * EnergyBalances                                                    | 0x0000 |
| * CurrentEnergyBalance                                              | 0x0001 |
| * EnergyPriorities                                                  | 0x0002 |
| * LowPowerModeSensitivities                                         | 0x0003 |
| * CurrentLowPowerModeSensitivity                                    | 0x0004 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster PowerTopology                                               | 0x009C |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * AvailableEndpoints                                                | 0x0000 |
| * ActiveEndpoints                                                   | 0x0001 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster EnergyEvseMode                                              | 0x009D |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * ChangeToMode                                                      |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * SupportedModes                                                    | 0x0000 |
| * CurrentMode                                                       | 0x0001 |
| * StartUpMode                                                       | 0x0002 |
| * OnMode                                                            | 0x0003 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command ChangeToMode
 */
class EnergyEvseModeChangeToMode : public ClusterCommand
{
public:
    EnergyEvseModeChangeToMode(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("change-to-mode", credsIssuerConfig)
    {
        AddArgument("NewMode", 0, UINT8_MAX, &mRequest.newMode);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyEvseMode::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::EnergyEvseMode::Commands::ChangeToMode::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyEvseMode::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::EnergyEvseMode::Commands::ChangeToMode::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::EnergyEvseMode::Commands::ChangeToMode::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster DeviceEnergyManagementMode                                  | 0x009F |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * ChangeToMode                                                      |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * SupportedModes                                                    | 0x0000 |
| * CurrentMode                                                       | 0x0001 |
| * StartUpMode                                                       | 0x0002 |
| * OnMode                                                            | 0x0003 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command ChangeToMode
 */
class DeviceEnergyManagementModeChangeToMode : public ClusterCommand
{
public:
    DeviceEnergyManagementModeChangeToMode(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("change-to-mode", credsIssuerConfig)
    {
        AddArgument("NewMode", 0, UINT8_MAX, &mRequest.newMode);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DeviceEnergyManagementMode::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DeviceEnergyManagementMode::Commands::ChangeToMode::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DeviceEnergyManagementMode::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DeviceEnergyManagementMode::Commands::ChangeToMode::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DeviceEnergyManagementMode::Commands::ChangeToMode::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster DoorLock                                                    | 0x0101 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * LockDoor                                                          |   0x00 |
| * UnlockDoor                                                        |   0x01 |
| * UnlockWithTimeout                                                 |   0x03 |
| * SetWeekDaySchedule                                                |   0x0B |
| * GetWeekDaySchedule                                                |   0x0C |
| * ClearWeekDaySchedule                                              |   0x0D |
| * SetYearDaySchedule                                                |   0x0E |
| * GetYearDaySchedule                                                |   0x0F |
| * ClearYearDaySchedule                                              |   0x10 |
| * SetHolidaySchedule                                                |   0x11 |
| * GetHolidaySchedule                                                |   0x12 |
| * ClearHolidaySchedule                                              |   0x13 |
| * SetUser                                                           |   0x1A |
| * GetUser                                                           |   0x1B |
| * ClearUser                                                         |   0x1D |
| * SetCredential                                                     |   0x22 |
| * GetCredentialStatus                                               |   0x24 |
| * ClearCredential                                                   |   0x26 |
| * UnboltDoor                                                        |   0x27 |
| * SetAliroReaderConfig                                              |   0x28 |
| * ClearAliroReaderConfig                                            |   0x29 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * LockState                                                         | 0x0000 |
| * LockType                                                          | 0x0001 |
| * ActuatorEnabled                                                   | 0x0002 |
| * DoorState                                                         | 0x0003 |
| * DoorOpenEvents                                                    | 0x0004 |
| * DoorClosedEvents                                                  | 0x0005 |
| * OpenPeriod                                                        | 0x0006 |
| * NumberOfTotalUsersSupported                                       | 0x0011 |
| * NumberOfPINUsersSupported                                         | 0x0012 |
| * NumberOfRFIDUsersSupported                                        | 0x0013 |
| * NumberOfWeekDaySchedulesSupportedPerUser                          | 0x0014 |
| * NumberOfYearDaySchedulesSupportedPerUser                          | 0x0015 |
| * NumberOfHolidaySchedulesSupported                                 | 0x0016 |
| * MaxPINCodeLength                                                  | 0x0017 |
| * MinPINCodeLength                                                  | 0x0018 |
| * MaxRFIDCodeLength                                                 | 0x0019 |
| * MinRFIDCodeLength                                                 | 0x001A |
| * CredentialRulesSupport                                            | 0x001B |
| * NumberOfCredentialsSupportedPerUser                               | 0x001C |
| * Language                                                          | 0x0021 |
| * LEDSettings                                                       | 0x0022 |
| * AutoRelockTime                                                    | 0x0023 |
| * SoundVolume                                                       | 0x0024 |
| * OperatingMode                                                     | 0x0025 |
| * SupportedOperatingModes                                           | 0x0026 |
| * DefaultConfigurationRegister                                      | 0x0027 |
| * EnableLocalProgramming                                            | 0x0028 |
| * EnableOneTouchLocking                                             | 0x0029 |
| * EnableInsideStatusLED                                             | 0x002A |
| * EnablePrivacyModeButton                                           | 0x002B |
| * LocalProgrammingFeatures                                          | 0x002C |
| * WrongCodeEntryLimit                                               | 0x0030 |
| * UserCodeTemporaryDisableTime                                      | 0x0031 |
| * SendPINOverTheAir                                                 | 0x0032 |
| * RequirePINforRemoteOperation                                      | 0x0033 |
| * ExpiringUserTimeout                                               | 0x0035 |
| * AliroReaderVerificationKey                                        | 0x0080 |
| * AliroReaderGroupIdentifier                                        | 0x0081 |
| * AliroReaderGroupSubIdentifier                                     | 0x0082 |
| * AliroExpeditedTransactionSupportedProtocolVersions                | 0x0083 |
| * AliroGroupResolvingKey                                            | 0x0084 |
| * AliroSupportedBLEUWBProtocolVersions                              | 0x0085 |
| * AliroBLEAdvertisingVersion                                        | 0x0086 |
| * NumberOfAliroCredentialIssuerKeysSupported                        | 0x0087 |
| * NumberOfAliroEndpointKeysSupported                                | 0x0088 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * DoorLockAlarm                                                     | 0x0000 |
| * DoorStateChange                                                   | 0x0001 |
| * LockOperation                                                     | 0x0002 |
| * LockOperationError                                                | 0x0003 |
| * LockUserChange                                                    | 0x0004 |
\*----------------------------------------------------------------------------*/

/*
 * Command LockDoor
 */
class DoorLockLockDoor : public ClusterCommand
{
public:
    DoorLockLockDoor(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("lock-door", credsIssuerConfig)
    {
        AddArgument("PINCode", &mRequest.PINCode);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::LockDoor::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::LockDoor::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::LockDoor::Type mRequest;
};

/*
 * Command UnlockDoor
 */
class DoorLockUnlockDoor : public ClusterCommand
{
public:
    DoorLockUnlockDoor(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("unlock-door", credsIssuerConfig)
    {
        AddArgument("PINCode", &mRequest.PINCode);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::UnlockDoor::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::UnlockDoor::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::UnlockDoor::Type mRequest;
};

/*
 * Command UnlockWithTimeout
 */
class DoorLockUnlockWithTimeout : public ClusterCommand
{
public:
    DoorLockUnlockWithTimeout(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("unlock-with-timeout", credsIssuerConfig)
    {
        AddArgument("Timeout", 0, UINT16_MAX, &mRequest.timeout);
        AddArgument("PINCode", &mRequest.PINCode);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::UnlockWithTimeout::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::UnlockWithTimeout::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::UnlockWithTimeout::Type mRequest;
};

/*
 * Command SetWeekDaySchedule
 */
class DoorLockSetWeekDaySchedule : public ClusterCommand
{
public:
    DoorLockSetWeekDaySchedule(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("set-week-day-schedule", credsIssuerConfig)
    {
        AddArgument("WeekDayIndex", 0, UINT8_MAX, &mRequest.weekDayIndex);
        AddArgument("UserIndex", 0, UINT16_MAX, &mRequest.userIndex);
        AddArgument("DaysMask", 0, UINT8_MAX, &mRequest.daysMask);
        AddArgument("StartHour", 0, UINT8_MAX, &mRequest.startHour);
        AddArgument("StartMinute", 0, UINT8_MAX, &mRequest.startMinute);
        AddArgument("EndHour", 0, UINT8_MAX, &mRequest.endHour);
        AddArgument("EndMinute", 0, UINT8_MAX, &mRequest.endMinute);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::SetWeekDaySchedule::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::SetWeekDaySchedule::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::SetWeekDaySchedule::Type mRequest;
};

/*
 * Command GetWeekDaySchedule
 */
class DoorLockGetWeekDaySchedule : public ClusterCommand
{
public:
    DoorLockGetWeekDaySchedule(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("get-week-day-schedule", credsIssuerConfig)
    {
        AddArgument("WeekDayIndex", 0, UINT8_MAX, &mRequest.weekDayIndex);
        AddArgument("UserIndex", 0, UINT16_MAX, &mRequest.userIndex);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::GetWeekDaySchedule::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::GetWeekDaySchedule::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::GetWeekDaySchedule::Type mRequest;
};

/*
 * Command ClearWeekDaySchedule
 */
class DoorLockClearWeekDaySchedule : public ClusterCommand
{
public:
    DoorLockClearWeekDaySchedule(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("clear-week-day-schedule", credsIssuerConfig)
    {
        AddArgument("WeekDayIndex", 0, UINT8_MAX, &mRequest.weekDayIndex);
        AddArgument("UserIndex", 0, UINT16_MAX, &mRequest.userIndex);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::ClearWeekDaySchedule::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::ClearWeekDaySchedule::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::ClearWeekDaySchedule::Type mRequest;
};

/*
 * Command SetYearDaySchedule
 */
class DoorLockSetYearDaySchedule : public ClusterCommand
{
public:
    DoorLockSetYearDaySchedule(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("set-year-day-schedule", credsIssuerConfig)
    {
        AddArgument("YearDayIndex", 0, UINT8_MAX, &mRequest.yearDayIndex);
        AddArgument("UserIndex", 0, UINT16_MAX, &mRequest.userIndex);
        AddArgument("LocalStartTime", 0, UINT32_MAX, &mRequest.localStartTime);
        AddArgument("LocalEndTime", 0, UINT32_MAX, &mRequest.localEndTime);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::SetYearDaySchedule::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::SetYearDaySchedule::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::SetYearDaySchedule::Type mRequest;
};

/*
 * Command GetYearDaySchedule
 */
class DoorLockGetYearDaySchedule : public ClusterCommand
{
public:
    DoorLockGetYearDaySchedule(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("get-year-day-schedule", credsIssuerConfig)
    {
        AddArgument("YearDayIndex", 0, UINT8_MAX, &mRequest.yearDayIndex);
        AddArgument("UserIndex", 0, UINT16_MAX, &mRequest.userIndex);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::GetYearDaySchedule::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::GetYearDaySchedule::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::GetYearDaySchedule::Type mRequest;
};

/*
 * Command ClearYearDaySchedule
 */
class DoorLockClearYearDaySchedule : public ClusterCommand
{
public:
    DoorLockClearYearDaySchedule(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("clear-year-day-schedule", credsIssuerConfig)
    {
        AddArgument("YearDayIndex", 0, UINT8_MAX, &mRequest.yearDayIndex);
        AddArgument("UserIndex", 0, UINT16_MAX, &mRequest.userIndex);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::ClearYearDaySchedule::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::ClearYearDaySchedule::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::ClearYearDaySchedule::Type mRequest;
};

/*
 * Command SetHolidaySchedule
 */
class DoorLockSetHolidaySchedule : public ClusterCommand
{
public:
    DoorLockSetHolidaySchedule(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("set-holiday-schedule", credsIssuerConfig)
    {
        AddArgument("HolidayIndex", 0, UINT8_MAX, &mRequest.holidayIndex);
        AddArgument("LocalStartTime", 0, UINT32_MAX, &mRequest.localStartTime);
        AddArgument("LocalEndTime", 0, UINT32_MAX, &mRequest.localEndTime);
        AddArgument("OperatingMode", 0, UINT8_MAX, &mRequest.operatingMode);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::SetHolidaySchedule::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::SetHolidaySchedule::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::SetHolidaySchedule::Type mRequest;
};

/*
 * Command GetHolidaySchedule
 */
class DoorLockGetHolidaySchedule : public ClusterCommand
{
public:
    DoorLockGetHolidaySchedule(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("get-holiday-schedule", credsIssuerConfig)
    {
        AddArgument("HolidayIndex", 0, UINT8_MAX, &mRequest.holidayIndex);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::GetHolidaySchedule::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::GetHolidaySchedule::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::GetHolidaySchedule::Type mRequest;
};

/*
 * Command ClearHolidaySchedule
 */
class DoorLockClearHolidaySchedule : public ClusterCommand
{
public:
    DoorLockClearHolidaySchedule(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("clear-holiday-schedule", credsIssuerConfig)
    {
        AddArgument("HolidayIndex", 0, UINT8_MAX, &mRequest.holidayIndex);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::ClearHolidaySchedule::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::ClearHolidaySchedule::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::ClearHolidaySchedule::Type mRequest;
};

/*
 * Command SetUser
 */
class DoorLockSetUser : public ClusterCommand
{
public:
    DoorLockSetUser(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("set-user", credsIssuerConfig)
    {
        AddArgument("OperationType", 0, UINT8_MAX, &mRequest.operationType);
        AddArgument("UserIndex", 0, UINT16_MAX, &mRequest.userIndex);
        AddArgument("UserName", &mRequest.userName);
        AddArgument("UserUniqueID", 0, UINT32_MAX, &mRequest.userUniqueID);
        AddArgument("UserStatus", 0, UINT8_MAX, &mRequest.userStatus);
        AddArgument("UserType", 0, UINT8_MAX, &mRequest.userType);
        AddArgument("CredentialRule", 0, UINT8_MAX, &mRequest.credentialRule);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::SetUser::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::SetUser::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::SetUser::Type mRequest;
};

/*
 * Command GetUser
 */
class DoorLockGetUser : public ClusterCommand
{
public:
    DoorLockGetUser(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("get-user", credsIssuerConfig)
    {
        AddArgument("UserIndex", 0, UINT16_MAX, &mRequest.userIndex);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::GetUser::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::GetUser::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::GetUser::Type mRequest;
};

/*
 * Command ClearUser
 */
class DoorLockClearUser : public ClusterCommand
{
public:
    DoorLockClearUser(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("clear-user", credsIssuerConfig)
    {
        AddArgument("UserIndex", 0, UINT16_MAX, &mRequest.userIndex);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::ClearUser::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::ClearUser::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::ClearUser::Type mRequest;
};

/*
 * Command SetCredential
 */
class DoorLockSetCredential : public ClusterCommand
{
public:
    DoorLockSetCredential(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("set-credential", credsIssuerConfig), mComplex_Credential(&mRequest.credential)
    {
        AddArgument("OperationType", 0, UINT8_MAX, &mRequest.operationType);
        AddArgument("Credential", &mComplex_Credential);
        AddArgument("CredentialData", &mRequest.credentialData);
        AddArgument("UserIndex", 0, UINT16_MAX, &mRequest.userIndex);
        AddArgument("UserStatus", 0, UINT8_MAX, &mRequest.userStatus);
        AddArgument("UserType", 0, UINT8_MAX, &mRequest.userType);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::SetCredential::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::SetCredential::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::SetCredential::Type mRequest;
    TypedComplexArgument<chip::app::Clusters::DoorLock::Structs::CredentialStruct::Type> mComplex_Credential;
};

/*
 * Command GetCredentialStatus
 */
class DoorLockGetCredentialStatus : public ClusterCommand
{
public:
    DoorLockGetCredentialStatus(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("get-credential-status", credsIssuerConfig), mComplex_Credential(&mRequest.credential)
    {
        AddArgument("Credential", &mComplex_Credential);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::GetCredentialStatus::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::GetCredentialStatus::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::GetCredentialStatus::Type mRequest;
    TypedComplexArgument<chip::app::Clusters::DoorLock::Structs::CredentialStruct::Type> mComplex_Credential;
};

/*
 * Command ClearCredential
 */
class DoorLockClearCredential : public ClusterCommand
{
public:
    DoorLockClearCredential(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("clear-credential", credsIssuerConfig), mComplex_Credential(&mRequest.credential)
    {
        AddArgument("Credential", &mComplex_Credential);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::ClearCredential::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::ClearCredential::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::ClearCredential::Type mRequest;
    TypedComplexArgument<chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::Structs::CredentialStruct::Type>>
        mComplex_Credential;
};

/*
 * Command UnboltDoor
 */
class DoorLockUnboltDoor : public ClusterCommand
{
public:
    DoorLockUnboltDoor(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("unbolt-door", credsIssuerConfig)
    {
        AddArgument("PINCode", &mRequest.PINCode);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::UnboltDoor::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::UnboltDoor::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::UnboltDoor::Type mRequest;
};

/*
 * Command SetAliroReaderConfig
 */
class DoorLockSetAliroReaderConfig : public ClusterCommand
{
public:
    DoorLockSetAliroReaderConfig(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("set-aliro-reader-config", credsIssuerConfig)
    {
        AddArgument("SigningKey", &mRequest.signingKey);
        AddArgument("VerificationKey", &mRequest.verificationKey);
        AddArgument("GroupIdentifier", &mRequest.groupIdentifier);
        AddArgument("GroupResolvingKey", &mRequest.groupResolvingKey);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::SetAliroReaderConfig::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::SetAliroReaderConfig::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::SetAliroReaderConfig::Type mRequest;
};

/*
 * Command ClearAliroReaderConfig
 */
class DoorLockClearAliroReaderConfig : public ClusterCommand
{
public:
    DoorLockClearAliroReaderConfig(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("clear-aliro-reader-config", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::ClearAliroReaderConfig::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::DoorLock::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::DoorLock::Commands::ClearAliroReaderConfig::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::ClearAliroReaderConfig::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster WindowCovering                                              | 0x0102 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * UpOrOpen                                                          |   0x00 |
| * DownOrClose                                                       |   0x01 |
| * StopMotion                                                        |   0x02 |
| * GoToLiftValue                                                     |   0x04 |
| * GoToLiftPercentage                                                |   0x05 |
| * GoToTiltValue                                                     |   0x07 |
| * GoToTiltPercentage                                                |   0x08 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * Type                                                              | 0x0000 |
| * PhysicalClosedLimitLift                                           | 0x0001 |
| * PhysicalClosedLimitTilt                                           | 0x0002 |
| * CurrentPositionLift                                               | 0x0003 |
| * CurrentPositionTilt                                               | 0x0004 |
| * NumberOfActuationsLift                                            | 0x0005 |
| * NumberOfActuationsTilt                                            | 0x0006 |
| * ConfigStatus                                                      | 0x0007 |
| * CurrentPositionLiftPercentage                                     | 0x0008 |
| * CurrentPositionTiltPercentage                                     | 0x0009 |
| * OperationalStatus                                                 | 0x000A |
| * TargetPositionLiftPercent100ths                                   | 0x000B |
| * TargetPositionTiltPercent100ths                                   | 0x000C |
| * EndProductType                                                    | 0x000D |
| * CurrentPositionLiftPercent100ths                                  | 0x000E |
| * CurrentPositionTiltPercent100ths                                  | 0x000F |
| * InstalledOpenLimitLift                                            | 0x0010 |
| * InstalledClosedLimitLift                                          | 0x0011 |
| * InstalledOpenLimitTilt                                            | 0x0012 |
| * InstalledClosedLimitTilt                                          | 0x0013 |
| * Mode                                                              | 0x0017 |
| * SafetyStatus                                                      | 0x001A |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command UpOrOpen
 */
class WindowCoveringUpOrOpen : public ClusterCommand
{
public:
    WindowCoveringUpOrOpen(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("up-or-open", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::WindowCovering::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::WindowCovering::Commands::UpOrOpen::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::WindowCovering::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::WindowCovering::Commands::UpOrOpen::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::WindowCovering::Commands::UpOrOpen::Type mRequest;
};

/*
 * Command DownOrClose
 */
class WindowCoveringDownOrClose : public ClusterCommand
{
public:
    WindowCoveringDownOrClose(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("down-or-close", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::WindowCovering::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::WindowCovering::Commands::DownOrClose::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::WindowCovering::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::WindowCovering::Commands::DownOrClose::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::WindowCovering::Commands::DownOrClose::Type mRequest;
};

/*
 * Command StopMotion
 */
class WindowCoveringStopMotion : public ClusterCommand
{
public:
    WindowCoveringStopMotion(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("stop-motion", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::WindowCovering::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::WindowCovering::Commands::StopMotion::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::WindowCovering::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::WindowCovering::Commands::StopMotion::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::WindowCovering::Commands::StopMotion::Type mRequest;
};

/*
 * Command GoToLiftValue
 */
class WindowCoveringGoToLiftValue : public ClusterCommand
{
public:
    WindowCoveringGoToLiftValue(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("go-to-lift-value", credsIssuerConfig)
    {
        AddArgument("LiftValue", 0, UINT16_MAX, &mRequest.liftValue);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::WindowCovering::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::WindowCovering::Commands::GoToLiftValue::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::WindowCovering::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::WindowCovering::Commands::GoToLiftValue::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::WindowCovering::Commands::GoToLiftValue::Type mRequest;
};

/*
 * Command GoToLiftPercentage
 */
class WindowCoveringGoToLiftPercentage : public ClusterCommand
{
public:
    WindowCoveringGoToLiftPercentage(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("go-to-lift-percentage", credsIssuerConfig)
    {
        AddArgument("LiftPercent100thsValue", 0, UINT16_MAX, &mRequest.liftPercent100thsValue);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::WindowCovering::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::WindowCovering::Commands::GoToLiftPercentage::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::WindowCovering::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::WindowCovering::Commands::GoToLiftPercentage::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::WindowCovering::Commands::GoToLiftPercentage::Type mRequest;
};

/*
 * Command GoToTiltValue
 */
class WindowCoveringGoToTiltValue : public ClusterCommand
{
public:
    WindowCoveringGoToTiltValue(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("go-to-tilt-value", credsIssuerConfig)
    {
        AddArgument("TiltValue", 0, UINT16_MAX, &mRequest.tiltValue);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::WindowCovering::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::WindowCovering::Commands::GoToTiltValue::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::WindowCovering::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::WindowCovering::Commands::GoToTiltValue::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::WindowCovering::Commands::GoToTiltValue::Type mRequest;
};

/*
 * Command GoToTiltPercentage
 */
class WindowCoveringGoToTiltPercentage : public ClusterCommand
{
public:
    WindowCoveringGoToTiltPercentage(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("go-to-tilt-percentage", credsIssuerConfig)
    {
        AddArgument("TiltPercent100thsValue", 0, UINT16_MAX, &mRequest.tiltPercent100thsValue);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::WindowCovering::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::WindowCovering::Commands::GoToTiltPercentage::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::WindowCovering::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::WindowCovering::Commands::GoToTiltPercentage::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::WindowCovering::Commands::GoToTiltPercentage::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster BarrierControl                                              | 0x0103 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * BarrierControlGoToPercent                                         |   0x00 |
| * BarrierControlStop                                                |   0x01 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * BarrierMovingState                                                | 0x0001 |
| * BarrierSafetyStatus                                               | 0x0002 |
| * BarrierCapabilities                                               | 0x0003 |
| * BarrierOpenEvents                                                 | 0x0004 |
| * BarrierCloseEvents                                                | 0x0005 |
| * BarrierCommandOpenEvents                                          | 0x0006 |
| * BarrierCommandCloseEvents                                         | 0x0007 |
| * BarrierOpenPeriod                                                 | 0x0008 |
| * BarrierClosePeriod                                                | 0x0009 |
| * BarrierPosition                                                   | 0x000A |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command BarrierControlGoToPercent
 */
class BarrierControlBarrierControlGoToPercent : public ClusterCommand
{
public:
    BarrierControlBarrierControlGoToPercent(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("barrier-control-go-to-percent", credsIssuerConfig)
    {
        AddArgument("PercentOpen", 0, UINT8_MAX, &mRequest.percentOpen);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::BarrierControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::BarrierControl::Commands::BarrierControlGoToPercent::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::BarrierControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::BarrierControl::Commands::BarrierControlGoToPercent::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::BarrierControl::Commands::BarrierControlGoToPercent::Type mRequest;
};

/*
 * Command BarrierControlStop
 */
class BarrierControlBarrierControlStop : public ClusterCommand
{
public:
    BarrierControlBarrierControlStop(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("barrier-control-stop", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::BarrierControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::BarrierControl::Commands::BarrierControlStop::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::BarrierControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::BarrierControl::Commands::BarrierControlStop::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::BarrierControl::Commands::BarrierControlStop::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster PumpConfigurationAndControl                                 | 0x0200 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * MaxPressure                                                       | 0x0000 |
| * MaxSpeed                                                          | 0x0001 |
| * MaxFlow                                                           | 0x0002 |
| * MinConstPressure                                                  | 0x0003 |
| * MaxConstPressure                                                  | 0x0004 |
| * MinCompPressure                                                   | 0x0005 |
| * MaxCompPressure                                                   | 0x0006 |
| * MinConstSpeed                                                     | 0x0007 |
| * MaxConstSpeed                                                     | 0x0008 |
| * MinConstFlow                                                      | 0x0009 |
| * MaxConstFlow                                                      | 0x000A |
| * MinConstTemp                                                      | 0x000B |
| * MaxConstTemp                                                      | 0x000C |
| * PumpStatus                                                        | 0x0010 |
| * EffectiveOperationMode                                            | 0x0011 |
| * EffectiveControlMode                                              | 0x0012 |
| * Capacity                                                          | 0x0013 |
| * Speed                                                             | 0x0014 |
| * LifetimeRunningHours                                              | 0x0015 |
| * Power                                                             | 0x0016 |
| * LifetimeEnergyConsumed                                            | 0x0017 |
| * OperationMode                                                     | 0x0020 |
| * ControlMode                                                       | 0x0021 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * SupplyVoltageLow                                                  | 0x0000 |
| * SupplyVoltageHigh                                                 | 0x0001 |
| * PowerMissingPhase                                                 | 0x0002 |
| * SystemPressureLow                                                 | 0x0003 |
| * SystemPressureHigh                                                | 0x0004 |
| * DryRunning                                                        | 0x0005 |
| * MotorTemperatureHigh                                              | 0x0006 |
| * PumpMotorFatalFailure                                             | 0x0007 |
| * ElectronicTemperatureHigh                                         | 0x0008 |
| * PumpBlocked                                                       | 0x0009 |
| * SensorFailure                                                     | 0x000A |
| * ElectronicNonFatalFailure                                         | 0x000B |
| * ElectronicFatalFailure                                            | 0x000C |
| * GeneralFault                                                      | 0x000D |
| * Leakage                                                           | 0x000E |
| * AirDetection                                                      | 0x000F |
| * TurbineOperation                                                  | 0x0010 |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster Thermostat                                                  | 0x0201 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * SetpointRaiseLower                                                |   0x00 |
| * SetWeeklySchedule                                                 |   0x01 |
| * GetWeeklySchedule                                                 |   0x02 |
| * ClearWeeklySchedule                                               |   0x03 |
| * SetActiveScheduleRequest                                          |   0x05 |
| * SetActivePresetRequest                                            |   0x06 |
| * StartPresetsSchedulesEditRequest                                  |   0x07 |
| * CancelPresetsSchedulesEditRequest                                 |   0x08 |
| * CommitPresetsSchedulesRequest                                     |   0x09 |
| * CancelSetActivePresetRequest                                      |   0x0A |
| * SetTemperatureSetpointHoldPolicy                                  |   0x0B |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * LocalTemperature                                                  | 0x0000 |
| * OutdoorTemperature                                                | 0x0001 |
| * Occupancy                                                         | 0x0002 |
| * AbsMinHeatSetpointLimit                                           | 0x0003 |
| * AbsMaxHeatSetpointLimit                                           | 0x0004 |
| * AbsMinCoolSetpointLimit                                           | 0x0005 |
| * AbsMaxCoolSetpointLimit                                           | 0x0006 |
| * PICoolingDemand                                                   | 0x0007 |
| * PIHeatingDemand                                                   | 0x0008 |
| * HVACSystemTypeConfiguration                                       | 0x0009 |
| * LocalTemperatureCalibration                                       | 0x0010 |
| * OccupiedCoolingSetpoint                                           | 0x0011 |
| * OccupiedHeatingSetpoint                                           | 0x0012 |
| * UnoccupiedCoolingSetpoint                                         | 0x0013 |
| * UnoccupiedHeatingSetpoint                                         | 0x0014 |
| * MinHeatSetpointLimit                                              | 0x0015 |
| * MaxHeatSetpointLimit                                              | 0x0016 |
| * MinCoolSetpointLimit                                              | 0x0017 |
| * MaxCoolSetpointLimit                                              | 0x0018 |
| * MinSetpointDeadBand                                               | 0x0019 |
| * RemoteSensing                                                     | 0x001A |
| * ControlSequenceOfOperation                                        | 0x001B |
| * SystemMode                                                        | 0x001C |
| * ThermostatRunningMode                                             | 0x001E |
| * StartOfWeek                                                       | 0x0020 |
| * NumberOfWeeklyTransitions                                         | 0x0021 |
| * NumberOfDailyTransitions                                          | 0x0022 |
| * TemperatureSetpointHold                                           | 0x0023 |
| * TemperatureSetpointHoldDuration                                   | 0x0024 |
| * ThermostatProgrammingOperationMode                                | 0x0025 |
| * ThermostatRunningState                                            | 0x0029 |
| * SetpointChangeSource                                              | 0x0030 |
| * SetpointChangeAmount                                              | 0x0031 |
| * SetpointChangeSourceTimestamp                                     | 0x0032 |
| * OccupiedSetback                                                   | 0x0034 |
| * OccupiedSetbackMin                                                | 0x0035 |
| * OccupiedSetbackMax                                                | 0x0036 |
| * UnoccupiedSetback                                                 | 0x0037 |
| * UnoccupiedSetbackMin                                              | 0x0038 |
| * UnoccupiedSetbackMax                                              | 0x0039 |
| * EmergencyHeatDelta                                                | 0x003A |
| * ACType                                                            | 0x0040 |
| * ACCapacity                                                        | 0x0041 |
| * ACRefrigerantType                                                 | 0x0042 |
| * ACCompressorType                                                  | 0x0043 |
| * ACErrorCode                                                       | 0x0044 |
| * ACLouverPosition                                                  | 0x0045 |
| * ACCoilTemperature                                                 | 0x0046 |
| * ACCapacityformat                                                  | 0x0047 |
| * PresetTypes                                                       | 0x0048 |
| * ScheduleTypes                                                     | 0x0049 |
| * NumberOfPresets                                                   | 0x004A |
| * NumberOfSchedules                                                 | 0x004B |
| * NumberOfScheduleTransitions                                       | 0x004C |
| * NumberOfScheduleTransitionPerDay                                  | 0x004D |
| * ActivePresetHandle                                                | 0x004E |
| * ActiveScheduleHandle                                              | 0x004F |
| * Presets                                                           | 0x0050 |
| * Schedules                                                         | 0x0051 |
| * PresetsSchedulesEditable                                          | 0x0052 |
| * TemperatureSetpointHoldPolicy                                     | 0x0053 |
| * SetpointHoldExpiryTimestamp                                       | 0x0054 |
| * QueuedPreset                                                      | 0x0055 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command SetpointRaiseLower
 */
class ThermostatSetpointRaiseLower : public ClusterCommand
{
public:
    ThermostatSetpointRaiseLower(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("setpoint-raise-lower", credsIssuerConfig)
    {
        AddArgument("Mode", 0, UINT8_MAX, &mRequest.mode);
        AddArgument("Amount", INT8_MIN, INT8_MAX, &mRequest.amount);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Thermostat::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Thermostat::Commands::SetpointRaiseLower::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Thermostat::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Thermostat::Commands::SetpointRaiseLower::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Thermostat::Commands::SetpointRaiseLower::Type mRequest;
};

/*
 * Command SetWeeklySchedule
 */
class ThermostatSetWeeklySchedule : public ClusterCommand
{
public:
    ThermostatSetWeeklySchedule(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("set-weekly-schedule", credsIssuerConfig), mComplex_Transitions(&mRequest.transitions)
    {
        AddArgument("NumberOfTransitionsForSequence", 0, UINT8_MAX, &mRequest.numberOfTransitionsForSequence);
        AddArgument("DayOfWeekForSequence", 0, UINT8_MAX, &mRequest.dayOfWeekForSequence);
        AddArgument("ModeForSequence", 0, UINT8_MAX, &mRequest.modeForSequence);
        AddArgument("Transitions", &mComplex_Transitions);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Thermostat::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Thermostat::Commands::SetWeeklySchedule::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Thermostat::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Thermostat::Commands::SetWeeklySchedule::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Thermostat::Commands::SetWeeklySchedule::Type mRequest;
    TypedComplexArgument<
        chip::app::DataModel::List<const chip::app::Clusters::Thermostat::Structs::WeeklyScheduleTransitionStruct::Type>>
        mComplex_Transitions;
};

/*
 * Command GetWeeklySchedule
 */
class ThermostatGetWeeklySchedule : public ClusterCommand
{
public:
    ThermostatGetWeeklySchedule(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("get-weekly-schedule", credsIssuerConfig)
    {
        AddArgument("DaysToReturn", 0, UINT8_MAX, &mRequest.daysToReturn);
        AddArgument("ModeToReturn", 0, UINT8_MAX, &mRequest.modeToReturn);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Thermostat::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Thermostat::Commands::GetWeeklySchedule::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Thermostat::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Thermostat::Commands::GetWeeklySchedule::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Thermostat::Commands::GetWeeklySchedule::Type mRequest;
};

/*
 * Command ClearWeeklySchedule
 */
class ThermostatClearWeeklySchedule : public ClusterCommand
{
public:
    ThermostatClearWeeklySchedule(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("clear-weekly-schedule", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Thermostat::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Thermostat::Commands::ClearWeeklySchedule::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Thermostat::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Thermostat::Commands::ClearWeeklySchedule::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Thermostat::Commands::ClearWeeklySchedule::Type mRequest;
};

/*
 * Command SetActiveScheduleRequest
 */
class ThermostatSetActiveScheduleRequest : public ClusterCommand
{
public:
    ThermostatSetActiveScheduleRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("set-active-schedule-request", credsIssuerConfig)
    {
        AddArgument("ScheduleHandle", &mRequest.scheduleHandle);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Thermostat::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Thermostat::Commands::SetActiveScheduleRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Thermostat::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Thermostat::Commands::SetActiveScheduleRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Thermostat::Commands::SetActiveScheduleRequest::Type mRequest;
};

/*
 * Command SetActivePresetRequest
 */
class ThermostatSetActivePresetRequest : public ClusterCommand
{
public:
    ThermostatSetActivePresetRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("set-active-preset-request", credsIssuerConfig)
    {
        AddArgument("PresetHandle", &mRequest.presetHandle);
        AddArgument("DelayMinutes", 0, UINT16_MAX, &mRequest.delayMinutes);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Thermostat::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Thermostat::Commands::SetActivePresetRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Thermostat::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Thermostat::Commands::SetActivePresetRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Thermostat::Commands::SetActivePresetRequest::Type mRequest;
};

/*
 * Command StartPresetsSchedulesEditRequest
 */
class ThermostatStartPresetsSchedulesEditRequest : public ClusterCommand
{
public:
    ThermostatStartPresetsSchedulesEditRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("start-presets-schedules-edit-request", credsIssuerConfig)
    {
        AddArgument("TimeoutSeconds", 0, UINT16_MAX, &mRequest.timeoutSeconds);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Thermostat::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Thermostat::Commands::StartPresetsSchedulesEditRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Thermostat::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Thermostat::Commands::StartPresetsSchedulesEditRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Thermostat::Commands::StartPresetsSchedulesEditRequest::Type mRequest;
};

/*
 * Command CancelPresetsSchedulesEditRequest
 */
class ThermostatCancelPresetsSchedulesEditRequest : public ClusterCommand
{
public:
    ThermostatCancelPresetsSchedulesEditRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("cancel-presets-schedules-edit-request", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Thermostat::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Thermostat::Commands::CancelPresetsSchedulesEditRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Thermostat::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Thermostat::Commands::CancelPresetsSchedulesEditRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Thermostat::Commands::CancelPresetsSchedulesEditRequest::Type mRequest;
};

/*
 * Command CommitPresetsSchedulesRequest
 */
class ThermostatCommitPresetsSchedulesRequest : public ClusterCommand
{
public:
    ThermostatCommitPresetsSchedulesRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("commit-presets-schedules-request", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Thermostat::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Thermostat::Commands::CommitPresetsSchedulesRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Thermostat::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Thermostat::Commands::CommitPresetsSchedulesRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Thermostat::Commands::CommitPresetsSchedulesRequest::Type mRequest;
};

/*
 * Command CancelSetActivePresetRequest
 */
class ThermostatCancelSetActivePresetRequest : public ClusterCommand
{
public:
    ThermostatCancelSetActivePresetRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("cancel-set-active-preset-request", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Thermostat::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Thermostat::Commands::CancelSetActivePresetRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Thermostat::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Thermostat::Commands::CancelSetActivePresetRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Thermostat::Commands::CancelSetActivePresetRequest::Type mRequest;
};

/*
 * Command SetTemperatureSetpointHoldPolicy
 */
class ThermostatSetTemperatureSetpointHoldPolicy : public ClusterCommand
{
public:
    ThermostatSetTemperatureSetpointHoldPolicy(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("set-temperature-setpoint-hold-policy", credsIssuerConfig)
    {
        AddArgument("TemperatureSetpointHoldPolicy", 0, UINT8_MAX, &mRequest.temperatureSetpointHoldPolicy);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Thermostat::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Thermostat::Commands::SetTemperatureSetpointHoldPolicy::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Thermostat::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Thermostat::Commands::SetTemperatureSetpointHoldPolicy::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Thermostat::Commands::SetTemperatureSetpointHoldPolicy::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster FanControl                                                  | 0x0202 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * Step                                                              |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * FanMode                                                           | 0x0000 |
| * FanModeSequence                                                   | 0x0001 |
| * PercentSetting                                                    | 0x0002 |
| * PercentCurrent                                                    | 0x0003 |
| * SpeedMax                                                          | 0x0004 |
| * SpeedSetting                                                      | 0x0005 |
| * SpeedCurrent                                                      | 0x0006 |
| * RockSupport                                                       | 0x0007 |
| * RockSetting                                                       | 0x0008 |
| * WindSupport                                                       | 0x0009 |
| * WindSetting                                                       | 0x000A |
| * AirflowDirection                                                  | 0x000B |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command Step
 */
class FanControlStep : public ClusterCommand
{
public:
    FanControlStep(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("step", credsIssuerConfig)
    {
        AddArgument("Direction", 0, UINT8_MAX, &mRequest.direction);
        AddArgument("Wrap", 0, 1, &mRequest.wrap);
        AddArgument("LowestOff", 0, 1, &mRequest.lowestOff);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::FanControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::FanControl::Commands::Step::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::FanControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::FanControl::Commands::Step::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::FanControl::Commands::Step::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster ThermostatUserInterfaceConfiguration                        | 0x0204 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * TemperatureDisplayMode                                            | 0x0000 |
| * KeypadLockout                                                     | 0x0001 |
| * ScheduleProgrammingVisibility                                     | 0x0002 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster ColorControl                                                | 0x0300 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * MoveToHue                                                         |   0x00 |
| * MoveHue                                                           |   0x01 |
| * StepHue                                                           |   0x02 |
| * MoveToSaturation                                                  |   0x03 |
| * MoveSaturation                                                    |   0x04 |
| * StepSaturation                                                    |   0x05 |
| * MoveToHueAndSaturation                                            |   0x06 |
| * MoveToColor                                                       |   0x07 |
| * MoveColor                                                         |   0x08 |
| * StepColor                                                         |   0x09 |
| * MoveToColorTemperature                                            |   0x0A |
| * EnhancedMoveToHue                                                 |   0x40 |
| * EnhancedMoveHue                                                   |   0x41 |
| * EnhancedStepHue                                                   |   0x42 |
| * EnhancedMoveToHueAndSaturation                                    |   0x43 |
| * ColorLoopSet                                                      |   0x44 |
| * StopMoveStep                                                      |   0x47 |
| * MoveColorTemperature                                              |   0x4B |
| * StepColorTemperature                                              |   0x4C |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * CurrentHue                                                        | 0x0000 |
| * CurrentSaturation                                                 | 0x0001 |
| * RemainingTime                                                     | 0x0002 |
| * CurrentX                                                          | 0x0003 |
| * CurrentY                                                          | 0x0004 |
| * DriftCompensation                                                 | 0x0005 |
| * CompensationText                                                  | 0x0006 |
| * ColorTemperatureMireds                                            | 0x0007 |
| * ColorMode                                                         | 0x0008 |
| * Options                                                           | 0x000F |
| * NumberOfPrimaries                                                 | 0x0010 |
| * Primary1X                                                         | 0x0011 |
| * Primary1Y                                                         | 0x0012 |
| * Primary1Intensity                                                 | 0x0013 |
| * Primary2X                                                         | 0x0015 |
| * Primary2Y                                                         | 0x0016 |
| * Primary2Intensity                                                 | 0x0017 |
| * Primary3X                                                         | 0x0019 |
| * Primary3Y                                                         | 0x001A |
| * Primary3Intensity                                                 | 0x001B |
| * Primary4X                                                         | 0x0020 |
| * Primary4Y                                                         | 0x0021 |
| * Primary4Intensity                                                 | 0x0022 |
| * Primary5X                                                         | 0x0024 |
| * Primary5Y                                                         | 0x0025 |
| * Primary5Intensity                                                 | 0x0026 |
| * Primary6X                                                         | 0x0028 |
| * Primary6Y                                                         | 0x0029 |
| * Primary6Intensity                                                 | 0x002A |
| * WhitePointX                                                       | 0x0030 |
| * WhitePointY                                                       | 0x0031 |
| * ColorPointRX                                                      | 0x0032 |
| * ColorPointRY                                                      | 0x0033 |
| * ColorPointRIntensity                                              | 0x0034 |
| * ColorPointGX                                                      | 0x0036 |
| * ColorPointGY                                                      | 0x0037 |
| * ColorPointGIntensity                                              | 0x0038 |
| * ColorPointBX                                                      | 0x003A |
| * ColorPointBY                                                      | 0x003B |
| * ColorPointBIntensity                                              | 0x003C |
| * EnhancedCurrentHue                                                | 0x4000 |
| * EnhancedColorMode                                                 | 0x4001 |
| * ColorLoopActive                                                   | 0x4002 |
| * ColorLoopDirection                                                | 0x4003 |
| * ColorLoopTime                                                     | 0x4004 |
| * ColorLoopStartEnhancedHue                                         | 0x4005 |
| * ColorLoopStoredEnhancedHue                                        | 0x4006 |
| * ColorCapabilities                                                 | 0x400A |
| * ColorTempPhysicalMinMireds                                        | 0x400B |
| * ColorTempPhysicalMaxMireds                                        | 0x400C |
| * CoupleColorTempToLevelMinMireds                                   | 0x400D |
| * StartUpColorTemperatureMireds                                     | 0x4010 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command MoveToHue
 */
class ColorControlMoveToHue : public ClusterCommand
{
public:
    ColorControlMoveToHue(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("move-to-hue", credsIssuerConfig)
    {
        AddArgument("Hue", 0, UINT8_MAX, &mRequest.hue);
        AddArgument("Direction", 0, UINT8_MAX, &mRequest.direction);
        AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::MoveToHue::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::MoveToHue::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::MoveToHue::Type mRequest;
};

/*
 * Command MoveHue
 */
class ColorControlMoveHue : public ClusterCommand
{
public:
    ColorControlMoveHue(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("move-hue", credsIssuerConfig)
    {
        AddArgument("MoveMode", 0, UINT8_MAX, &mRequest.moveMode);
        AddArgument("Rate", 0, UINT8_MAX, &mRequest.rate);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::MoveHue::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::MoveHue::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::MoveHue::Type mRequest;
};

/*
 * Command StepHue
 */
class ColorControlStepHue : public ClusterCommand
{
public:
    ColorControlStepHue(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("step-hue", credsIssuerConfig)
    {
        AddArgument("StepMode", 0, UINT8_MAX, &mRequest.stepMode);
        AddArgument("StepSize", 0, UINT8_MAX, &mRequest.stepSize);
        AddArgument("TransitionTime", 0, UINT8_MAX, &mRequest.transitionTime);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::StepHue::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::StepHue::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::StepHue::Type mRequest;
};

/*
 * Command MoveToSaturation
 */
class ColorControlMoveToSaturation : public ClusterCommand
{
public:
    ColorControlMoveToSaturation(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("move-to-saturation", credsIssuerConfig)
    {
        AddArgument("Saturation", 0, UINT8_MAX, &mRequest.saturation);
        AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::MoveToSaturation::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::MoveToSaturation::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::MoveToSaturation::Type mRequest;
};

/*
 * Command MoveSaturation
 */
class ColorControlMoveSaturation : public ClusterCommand
{
public:
    ColorControlMoveSaturation(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("move-saturation", credsIssuerConfig)
    {
        AddArgument("MoveMode", 0, UINT8_MAX, &mRequest.moveMode);
        AddArgument("Rate", 0, UINT8_MAX, &mRequest.rate);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::MoveSaturation::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::MoveSaturation::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::MoveSaturation::Type mRequest;
};

/*
 * Command StepSaturation
 */
class ColorControlStepSaturation : public ClusterCommand
{
public:
    ColorControlStepSaturation(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("step-saturation", credsIssuerConfig)
    {
        AddArgument("StepMode", 0, UINT8_MAX, &mRequest.stepMode);
        AddArgument("StepSize", 0, UINT8_MAX, &mRequest.stepSize);
        AddArgument("TransitionTime", 0, UINT8_MAX, &mRequest.transitionTime);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::StepSaturation::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::StepSaturation::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::StepSaturation::Type mRequest;
};

/*
 * Command MoveToHueAndSaturation
 */
class ColorControlMoveToHueAndSaturation : public ClusterCommand
{
public:
    ColorControlMoveToHueAndSaturation(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("move-to-hue-and-saturation", credsIssuerConfig)
    {
        AddArgument("Hue", 0, UINT8_MAX, &mRequest.hue);
        AddArgument("Saturation", 0, UINT8_MAX, &mRequest.saturation);
        AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::MoveToHueAndSaturation::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::MoveToHueAndSaturation::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::MoveToHueAndSaturation::Type mRequest;
};

/*
 * Command MoveToColor
 */
class ColorControlMoveToColor : public ClusterCommand
{
public:
    ColorControlMoveToColor(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("move-to-color", credsIssuerConfig)
    {
        AddArgument("ColorX", 0, UINT16_MAX, &mRequest.colorX);
        AddArgument("ColorY", 0, UINT16_MAX, &mRequest.colorY);
        AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::MoveToColor::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::MoveToColor::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::MoveToColor::Type mRequest;
};

/*
 * Command MoveColor
 */
class ColorControlMoveColor : public ClusterCommand
{
public:
    ColorControlMoveColor(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("move-color", credsIssuerConfig)
    {
        AddArgument("RateX", INT16_MIN, INT16_MAX, &mRequest.rateX);
        AddArgument("RateY", INT16_MIN, INT16_MAX, &mRequest.rateY);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::MoveColor::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::MoveColor::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::MoveColor::Type mRequest;
};

/*
 * Command StepColor
 */
class ColorControlStepColor : public ClusterCommand
{
public:
    ColorControlStepColor(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("step-color", credsIssuerConfig)
    {
        AddArgument("StepX", INT16_MIN, INT16_MAX, &mRequest.stepX);
        AddArgument("StepY", INT16_MIN, INT16_MAX, &mRequest.stepY);
        AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::StepColor::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::StepColor::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::StepColor::Type mRequest;
};

/*
 * Command MoveToColorTemperature
 */
class ColorControlMoveToColorTemperature : public ClusterCommand
{
public:
    ColorControlMoveToColorTemperature(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("move-to-color-temperature", credsIssuerConfig)
    {
        AddArgument("ColorTemperatureMireds", 0, UINT16_MAX, &mRequest.colorTemperatureMireds);
        AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::MoveToColorTemperature::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::MoveToColorTemperature::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::MoveToColorTemperature::Type mRequest;
};

/*
 * Command EnhancedMoveToHue
 */
class ColorControlEnhancedMoveToHue : public ClusterCommand
{
public:
    ColorControlEnhancedMoveToHue(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("enhanced-move-to-hue", credsIssuerConfig)
    {
        AddArgument("EnhancedHue", 0, UINT16_MAX, &mRequest.enhancedHue);
        AddArgument("Direction", 0, UINT8_MAX, &mRequest.direction);
        AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::EnhancedMoveToHue::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::EnhancedMoveToHue::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::EnhancedMoveToHue::Type mRequest;
};

/*
 * Command EnhancedMoveHue
 */
class ColorControlEnhancedMoveHue : public ClusterCommand
{
public:
    ColorControlEnhancedMoveHue(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("enhanced-move-hue", credsIssuerConfig)
    {
        AddArgument("MoveMode", 0, UINT8_MAX, &mRequest.moveMode);
        AddArgument("Rate", 0, UINT16_MAX, &mRequest.rate);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::EnhancedMoveHue::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::EnhancedMoveHue::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::EnhancedMoveHue::Type mRequest;
};

/*
 * Command EnhancedStepHue
 */
class ColorControlEnhancedStepHue : public ClusterCommand
{
public:
    ColorControlEnhancedStepHue(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("enhanced-step-hue", credsIssuerConfig)
    {
        AddArgument("StepMode", 0, UINT8_MAX, &mRequest.stepMode);
        AddArgument("StepSize", 0, UINT16_MAX, &mRequest.stepSize);
        AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::EnhancedStepHue::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::EnhancedStepHue::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::EnhancedStepHue::Type mRequest;
};

/*
 * Command EnhancedMoveToHueAndSaturation
 */
class ColorControlEnhancedMoveToHueAndSaturation : public ClusterCommand
{
public:
    ColorControlEnhancedMoveToHueAndSaturation(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("enhanced-move-to-hue-and-saturation", credsIssuerConfig)
    {
        AddArgument("EnhancedHue", 0, UINT16_MAX, &mRequest.enhancedHue);
        AddArgument("Saturation", 0, UINT8_MAX, &mRequest.saturation);
        AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::EnhancedMoveToHueAndSaturation::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::EnhancedMoveToHueAndSaturation::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::EnhancedMoveToHueAndSaturation::Type mRequest;
};

/*
 * Command ColorLoopSet
 */
class ColorControlColorLoopSet : public ClusterCommand
{
public:
    ColorControlColorLoopSet(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("color-loop-set", credsIssuerConfig)
    {
        AddArgument("UpdateFlags", 0, UINT8_MAX, &mRequest.updateFlags);
        AddArgument("Action", 0, UINT8_MAX, &mRequest.action);
        AddArgument("Direction", 0, UINT8_MAX, &mRequest.direction);
        AddArgument("Time", 0, UINT16_MAX, &mRequest.time);
        AddArgument("StartHue", 0, UINT16_MAX, &mRequest.startHue);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::ColorLoopSet::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::ColorLoopSet::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::ColorLoopSet::Type mRequest;
};

/*
 * Command StopMoveStep
 */
class ColorControlStopMoveStep : public ClusterCommand
{
public:
    ColorControlStopMoveStep(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("stop-move-step", credsIssuerConfig)
    {
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::StopMoveStep::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::StopMoveStep::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::StopMoveStep::Type mRequest;
};

/*
 * Command MoveColorTemperature
 */
class ColorControlMoveColorTemperature : public ClusterCommand
{
public:
    ColorControlMoveColorTemperature(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("move-color-temperature", credsIssuerConfig)
    {
        AddArgument("MoveMode", 0, UINT8_MAX, &mRequest.moveMode);
        AddArgument("Rate", 0, UINT16_MAX, &mRequest.rate);
        AddArgument("ColorTemperatureMinimumMireds", 0, UINT16_MAX, &mRequest.colorTemperatureMinimumMireds);
        AddArgument("ColorTemperatureMaximumMireds", 0, UINT16_MAX, &mRequest.colorTemperatureMaximumMireds);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::MoveColorTemperature::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::MoveColorTemperature::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::MoveColorTemperature::Type mRequest;
};

/*
 * Command StepColorTemperature
 */
class ColorControlStepColorTemperature : public ClusterCommand
{
public:
    ColorControlStepColorTemperature(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("step-color-temperature", credsIssuerConfig)
    {
        AddArgument("StepMode", 0, UINT8_MAX, &mRequest.stepMode);
        AddArgument("StepSize", 0, UINT16_MAX, &mRequest.stepSize);
        AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
        AddArgument("ColorTemperatureMinimumMireds", 0, UINT16_MAX, &mRequest.colorTemperatureMinimumMireds);
        AddArgument("ColorTemperatureMaximumMireds", 0, UINT16_MAX, &mRequest.colorTemperatureMaximumMireds);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::StepColorTemperature::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ColorControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ColorControl::Commands::StepColorTemperature::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::StepColorTemperature::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster BallastConfiguration                                        | 0x0301 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * PhysicalMinLevel                                                  | 0x0000 |
| * PhysicalMaxLevel                                                  | 0x0001 |
| * BallastStatus                                                     | 0x0002 |
| * MinLevel                                                          | 0x0010 |
| * MaxLevel                                                          | 0x0011 |
| * IntrinsicBallastFactor                                            | 0x0014 |
| * BallastFactorAdjustment                                           | 0x0015 |
| * LampQuantity                                                      | 0x0020 |
| * LampType                                                          | 0x0030 |
| * LampManufacturer                                                  | 0x0031 |
| * LampRatedHours                                                    | 0x0032 |
| * LampBurnHours                                                     | 0x0033 |
| * LampAlarmMode                                                     | 0x0034 |
| * LampBurnHoursTripPoint                                            | 0x0035 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster IlluminanceMeasurement                                      | 0x0400 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * MeasuredValue                                                     | 0x0000 |
| * MinMeasuredValue                                                  | 0x0001 |
| * MaxMeasuredValue                                                  | 0x0002 |
| * Tolerance                                                         | 0x0003 |
| * LightSensorType                                                   | 0x0004 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster TemperatureMeasurement                                      | 0x0402 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * MeasuredValue                                                     | 0x0000 |
| * MinMeasuredValue                                                  | 0x0001 |
| * MaxMeasuredValue                                                  | 0x0002 |
| * Tolerance                                                         | 0x0003 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster PressureMeasurement                                         | 0x0403 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * MeasuredValue                                                     | 0x0000 |
| * MinMeasuredValue                                                  | 0x0001 |
| * MaxMeasuredValue                                                  | 0x0002 |
| * Tolerance                                                         | 0x0003 |
| * ScaledValue                                                       | 0x0010 |
| * MinScaledValue                                                    | 0x0011 |
| * MaxScaledValue                                                    | 0x0012 |
| * ScaledTolerance                                                   | 0x0013 |
| * Scale                                                             | 0x0014 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster FlowMeasurement                                             | 0x0404 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * MeasuredValue                                                     | 0x0000 |
| * MinMeasuredValue                                                  | 0x0001 |
| * MaxMeasuredValue                                                  | 0x0002 |
| * Tolerance                                                         | 0x0003 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster RelativeHumidityMeasurement                                 | 0x0405 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * MeasuredValue                                                     | 0x0000 |
| * MinMeasuredValue                                                  | 0x0001 |
| * MaxMeasuredValue                                                  | 0x0002 |
| * Tolerance                                                         | 0x0003 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster OccupancySensing                                            | 0x0406 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * Occupancy                                                         | 0x0000 |
| * OccupancySensorType                                               | 0x0001 |
| * OccupancySensorTypeBitmap                                         | 0x0002 |
| * PIROccupiedToUnoccupiedDelay                                      | 0x0010 |
| * PIRUnoccupiedToOccupiedDelay                                      | 0x0011 |
| * PIRUnoccupiedToOccupiedThreshold                                  | 0x0012 |
| * UltrasonicOccupiedToUnoccupiedDelay                               | 0x0020 |
| * UltrasonicUnoccupiedToOccupiedDelay                               | 0x0021 |
| * UltrasonicUnoccupiedToOccupiedThreshold                           | 0x0022 |
| * PhysicalContactOccupiedToUnoccupiedDelay                          | 0x0030 |
| * PhysicalContactUnoccupiedToOccupiedDelay                          | 0x0031 |
| * PhysicalContactUnoccupiedToOccupiedThreshold                      | 0x0032 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster CarbonMonoxideConcentrationMeasurement                      | 0x040C |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * MeasuredValue                                                     | 0x0000 |
| * MinMeasuredValue                                                  | 0x0001 |
| * MaxMeasuredValue                                                  | 0x0002 |
| * PeakMeasuredValue                                                 | 0x0003 |
| * PeakMeasuredValueWindow                                           | 0x0004 |
| * AverageMeasuredValue                                              | 0x0005 |
| * AverageMeasuredValueWindow                                        | 0x0006 |
| * Uncertainty                                                       | 0x0007 |
| * MeasurementUnit                                                   | 0x0008 |
| * MeasurementMedium                                                 | 0x0009 |
| * LevelValue                                                        | 0x000A |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster CarbonDioxideConcentrationMeasurement                       | 0x040D |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * MeasuredValue                                                     | 0x0000 |
| * MinMeasuredValue                                                  | 0x0001 |
| * MaxMeasuredValue                                                  | 0x0002 |
| * PeakMeasuredValue                                                 | 0x0003 |
| * PeakMeasuredValueWindow                                           | 0x0004 |
| * AverageMeasuredValue                                              | 0x0005 |
| * AverageMeasuredValueWindow                                        | 0x0006 |
| * Uncertainty                                                       | 0x0007 |
| * MeasurementUnit                                                   | 0x0008 |
| * MeasurementMedium                                                 | 0x0009 |
| * LevelValue                                                        | 0x000A |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster NitrogenDioxideConcentrationMeasurement                     | 0x0413 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * MeasuredValue                                                     | 0x0000 |
| * MinMeasuredValue                                                  | 0x0001 |
| * MaxMeasuredValue                                                  | 0x0002 |
| * PeakMeasuredValue                                                 | 0x0003 |
| * PeakMeasuredValueWindow                                           | 0x0004 |
| * AverageMeasuredValue                                              | 0x0005 |
| * AverageMeasuredValueWindow                                        | 0x0006 |
| * Uncertainty                                                       | 0x0007 |
| * MeasurementUnit                                                   | 0x0008 |
| * MeasurementMedium                                                 | 0x0009 |
| * LevelValue                                                        | 0x000A |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster OzoneConcentrationMeasurement                               | 0x0415 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * MeasuredValue                                                     | 0x0000 |
| * MinMeasuredValue                                                  | 0x0001 |
| * MaxMeasuredValue                                                  | 0x0002 |
| * PeakMeasuredValue                                                 | 0x0003 |
| * PeakMeasuredValueWindow                                           | 0x0004 |
| * AverageMeasuredValue                                              | 0x0005 |
| * AverageMeasuredValueWindow                                        | 0x0006 |
| * Uncertainty                                                       | 0x0007 |
| * MeasurementUnit                                                   | 0x0008 |
| * MeasurementMedium                                                 | 0x0009 |
| * LevelValue                                                        | 0x000A |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster Pm25ConcentrationMeasurement                                | 0x042A |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * MeasuredValue                                                     | 0x0000 |
| * MinMeasuredValue                                                  | 0x0001 |
| * MaxMeasuredValue                                                  | 0x0002 |
| * PeakMeasuredValue                                                 | 0x0003 |
| * PeakMeasuredValueWindow                                           | 0x0004 |
| * AverageMeasuredValue                                              | 0x0005 |
| * AverageMeasuredValueWindow                                        | 0x0006 |
| * Uncertainty                                                       | 0x0007 |
| * MeasurementUnit                                                   | 0x0008 |
| * MeasurementMedium                                                 | 0x0009 |
| * LevelValue                                                        | 0x000A |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster FormaldehydeConcentrationMeasurement                        | 0x042B |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * MeasuredValue                                                     | 0x0000 |
| * MinMeasuredValue                                                  | 0x0001 |
| * MaxMeasuredValue                                                  | 0x0002 |
| * PeakMeasuredValue                                                 | 0x0003 |
| * PeakMeasuredValueWindow                                           | 0x0004 |
| * AverageMeasuredValue                                              | 0x0005 |
| * AverageMeasuredValueWindow                                        | 0x0006 |
| * Uncertainty                                                       | 0x0007 |
| * MeasurementUnit                                                   | 0x0008 |
| * MeasurementMedium                                                 | 0x0009 |
| * LevelValue                                                        | 0x000A |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster Pm1ConcentrationMeasurement                                 | 0x042C |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * MeasuredValue                                                     | 0x0000 |
| * MinMeasuredValue                                                  | 0x0001 |
| * MaxMeasuredValue                                                  | 0x0002 |
| * PeakMeasuredValue                                                 | 0x0003 |
| * PeakMeasuredValueWindow                                           | 0x0004 |
| * AverageMeasuredValue                                              | 0x0005 |
| * AverageMeasuredValueWindow                                        | 0x0006 |
| * Uncertainty                                                       | 0x0007 |
| * MeasurementUnit                                                   | 0x0008 |
| * MeasurementMedium                                                 | 0x0009 |
| * LevelValue                                                        | 0x000A |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster Pm10ConcentrationMeasurement                                | 0x042D |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * MeasuredValue                                                     | 0x0000 |
| * MinMeasuredValue                                                  | 0x0001 |
| * MaxMeasuredValue                                                  | 0x0002 |
| * PeakMeasuredValue                                                 | 0x0003 |
| * PeakMeasuredValueWindow                                           | 0x0004 |
| * AverageMeasuredValue                                              | 0x0005 |
| * AverageMeasuredValueWindow                                        | 0x0006 |
| * Uncertainty                                                       | 0x0007 |
| * MeasurementUnit                                                   | 0x0008 |
| * MeasurementMedium                                                 | 0x0009 |
| * LevelValue                                                        | 0x000A |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster TotalVolatileOrganicCompoundsConcentrationMeasurement       | 0x042E |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * MeasuredValue                                                     | 0x0000 |
| * MinMeasuredValue                                                  | 0x0001 |
| * MaxMeasuredValue                                                  | 0x0002 |
| * PeakMeasuredValue                                                 | 0x0003 |
| * PeakMeasuredValueWindow                                           | 0x0004 |
| * AverageMeasuredValue                                              | 0x0005 |
| * AverageMeasuredValueWindow                                        | 0x0006 |
| * Uncertainty                                                       | 0x0007 |
| * MeasurementUnit                                                   | 0x0008 |
| * MeasurementMedium                                                 | 0x0009 |
| * LevelValue                                                        | 0x000A |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster RadonConcentrationMeasurement                               | 0x042F |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * MeasuredValue                                                     | 0x0000 |
| * MinMeasuredValue                                                  | 0x0001 |
| * MaxMeasuredValue                                                  | 0x0002 |
| * PeakMeasuredValue                                                 | 0x0003 |
| * PeakMeasuredValueWindow                                           | 0x0004 |
| * AverageMeasuredValue                                              | 0x0005 |
| * AverageMeasuredValueWindow                                        | 0x0006 |
| * Uncertainty                                                       | 0x0007 |
| * MeasurementUnit                                                   | 0x0008 |
| * MeasurementMedium                                                 | 0x0009 |
| * LevelValue                                                        | 0x000A |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster WakeOnLan                                                   | 0x0503 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * MACAddress                                                        | 0x0000 |
| * LinkLocalAddress                                                  | 0x0001 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster Channel                                                     | 0x0504 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * ChangeChannel                                                     |   0x00 |
| * ChangeChannelByNumber                                             |   0x02 |
| * SkipChannel                                                       |   0x03 |
| * GetProgramGuide                                                   |   0x04 |
| * RecordProgram                                                     |   0x06 |
| * CancelRecordProgram                                               |   0x07 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * ChannelList                                                       | 0x0000 |
| * Lineup                                                            | 0x0001 |
| * CurrentChannel                                                    | 0x0002 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command ChangeChannel
 */
class ChannelChangeChannel : public ClusterCommand
{
public:
    ChannelChangeChannel(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("change-channel", credsIssuerConfig)
    {
        AddArgument("Match", &mRequest.match);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Channel::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Channel::Commands::ChangeChannel::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Channel::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Channel::Commands::ChangeChannel::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Channel::Commands::ChangeChannel::Type mRequest;
};

/*
 * Command ChangeChannelByNumber
 */
class ChannelChangeChannelByNumber : public ClusterCommand
{
public:
    ChannelChangeChannelByNumber(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("change-channel-by-number", credsIssuerConfig)
    {
        AddArgument("MajorNumber", 0, UINT16_MAX, &mRequest.majorNumber);
        AddArgument("MinorNumber", 0, UINT16_MAX, &mRequest.minorNumber);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Channel::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Channel::Commands::ChangeChannelByNumber::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Channel::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Channel::Commands::ChangeChannelByNumber::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Channel::Commands::ChangeChannelByNumber::Type mRequest;
};

/*
 * Command SkipChannel
 */
class ChannelSkipChannel : public ClusterCommand
{
public:
    ChannelSkipChannel(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("skip-channel", credsIssuerConfig)
    {
        AddArgument("Count", INT16_MIN, INT16_MAX, &mRequest.count);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Channel::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Channel::Commands::SkipChannel::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Channel::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Channel::Commands::SkipChannel::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Channel::Commands::SkipChannel::Type mRequest;
};

/*
 * Command GetProgramGuide
 */
class ChannelGetProgramGuide : public ClusterCommand
{
public:
    ChannelGetProgramGuide(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("get-program-guide", credsIssuerConfig), mComplex_ChannelList(&mRequest.channelList),
        mComplex_PageToken(&mRequest.pageToken), mComplex_ExternalIDList(&mRequest.externalIDList)
    {
        AddArgument("StartTime", 0, UINT32_MAX, &mRequest.startTime);
        AddArgument("EndTime", 0, UINT32_MAX, &mRequest.endTime);
        AddArgument("ChannelList", &mComplex_ChannelList, "", Argument::kOptional);
        AddArgument("PageToken", &mComplex_PageToken, "", Argument::kOptional);
        AddArgument("RecordingFlag", 0, UINT32_MAX, &mRequest.recordingFlag);
        AddArgument("ExternalIDList", &mComplex_ExternalIDList, "", Argument::kOptional);
        AddArgument("Data", &mRequest.data);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Channel::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Channel::Commands::GetProgramGuide::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Channel::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Channel::Commands::GetProgramGuide::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Channel::Commands::GetProgramGuide::Type mRequest;
    TypedComplexArgument<
        chip::Optional<chip::app::DataModel::List<const chip::app::Clusters::Channel::Structs::ChannelInfoStruct::Type>>>
        mComplex_ChannelList;
    TypedComplexArgument<chip::Optional<chip::app::Clusters::Channel::Structs::PageTokenStruct::Type>> mComplex_PageToken;
    TypedComplexArgument<
        chip::Optional<chip::app::DataModel::List<const chip::app::Clusters::Channel::Structs::AdditionalInfoStruct::Type>>>
        mComplex_ExternalIDList;
};

/*
 * Command RecordProgram
 */
class ChannelRecordProgram : public ClusterCommand
{
public:
    ChannelRecordProgram(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("record-program", credsIssuerConfig), mComplex_ExternalIDList(&mRequest.externalIDList)
    {
        AddArgument("ProgramIdentifier", &mRequest.programIdentifier);
        AddArgument("ShouldRecordSeries", 0, 1, &mRequest.shouldRecordSeries);
        AddArgument("ExternalIDList", &mComplex_ExternalIDList);
        AddArgument("Data", &mRequest.data);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Channel::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Channel::Commands::RecordProgram::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Channel::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Channel::Commands::RecordProgram::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Channel::Commands::RecordProgram::Type mRequest;
    TypedComplexArgument<chip::app::DataModel::List<const chip::app::Clusters::Channel::Structs::AdditionalInfoStruct::Type>>
        mComplex_ExternalIDList;
};

/*
 * Command CancelRecordProgram
 */
class ChannelCancelRecordProgram : public ClusterCommand
{
public:
    ChannelCancelRecordProgram(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("cancel-record-program", credsIssuerConfig), mComplex_ExternalIDList(&mRequest.externalIDList)
    {
        AddArgument("ProgramIdentifier", &mRequest.programIdentifier);
        AddArgument("ShouldRecordSeries", 0, 1, &mRequest.shouldRecordSeries);
        AddArgument("ExternalIDList", &mComplex_ExternalIDList);
        AddArgument("Data", &mRequest.data);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Channel::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Channel::Commands::CancelRecordProgram::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::Channel::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::Channel::Commands::CancelRecordProgram::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::Channel::Commands::CancelRecordProgram::Type mRequest;
    TypedComplexArgument<chip::app::DataModel::List<const chip::app::Clusters::Channel::Structs::AdditionalInfoStruct::Type>>
        mComplex_ExternalIDList;
};

/*----------------------------------------------------------------------------*\
| Cluster TargetNavigator                                             | 0x0505 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * NavigateTarget                                                    |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * TargetList                                                        | 0x0000 |
| * CurrentTarget                                                     | 0x0001 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * TargetUpdated                                                     | 0x0000 |
\*----------------------------------------------------------------------------*/

/*
 * Command NavigateTarget
 */
class TargetNavigatorNavigateTarget : public ClusterCommand
{
public:
    TargetNavigatorNavigateTarget(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("navigate-target", credsIssuerConfig)
    {
        AddArgument("Target", 0, UINT8_MAX, &mRequest.target);
        AddArgument("Data", &mRequest.data);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::TargetNavigator::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::TargetNavigator::Commands::NavigateTarget::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::TargetNavigator::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::TargetNavigator::Commands::NavigateTarget::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::TargetNavigator::Commands::NavigateTarget::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster MediaPlayback                                               | 0x0506 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * Play                                                              |   0x00 |
| * Pause                                                             |   0x01 |
| * Stop                                                              |   0x02 |
| * StartOver                                                         |   0x03 |
| * Previous                                                          |   0x04 |
| * Next                                                              |   0x05 |
| * Rewind                                                            |   0x06 |
| * FastForward                                                       |   0x07 |
| * SkipForward                                                       |   0x08 |
| * SkipBackward                                                      |   0x09 |
| * Seek                                                              |   0x0B |
| * ActivateAudioTrack                                                |   0x0C |
| * ActivateTextTrack                                                 |   0x0D |
| * DeactivateTextTrack                                               |   0x0E |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * CurrentState                                                      | 0x0000 |
| * StartTime                                                         | 0x0001 |
| * Duration                                                          | 0x0002 |
| * SampledPosition                                                   | 0x0003 |
| * PlaybackSpeed                                                     | 0x0004 |
| * SeekRangeEnd                                                      | 0x0005 |
| * SeekRangeStart                                                    | 0x0006 |
| * ActiveAudioTrack                                                  | 0x0007 |
| * AvailableAudioTracks                                              | 0x0008 |
| * ActiveTextTrack                                                   | 0x0009 |
| * AvailableTextTracks                                               | 0x000A |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * StateChanged                                                      | 0x0000 |
\*----------------------------------------------------------------------------*/

/*
 * Command Play
 */
class MediaPlaybackPlay : public ClusterCommand
{
public:
    MediaPlaybackPlay(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("play", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaPlayback::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaPlayback::Commands::Play::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaPlayback::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaPlayback::Commands::Play::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::MediaPlayback::Commands::Play::Type mRequest;
};

/*
 * Command Pause
 */
class MediaPlaybackPause : public ClusterCommand
{
public:
    MediaPlaybackPause(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("pause", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaPlayback::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaPlayback::Commands::Pause::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaPlayback::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaPlayback::Commands::Pause::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::MediaPlayback::Commands::Pause::Type mRequest;
};

/*
 * Command Stop
 */
class MediaPlaybackStop : public ClusterCommand
{
public:
    MediaPlaybackStop(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("stop", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaPlayback::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaPlayback::Commands::Stop::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaPlayback::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaPlayback::Commands::Stop::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::MediaPlayback::Commands::Stop::Type mRequest;
};

/*
 * Command StartOver
 */
class MediaPlaybackStartOver : public ClusterCommand
{
public:
    MediaPlaybackStartOver(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("start-over", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaPlayback::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaPlayback::Commands::StartOver::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaPlayback::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaPlayback::Commands::StartOver::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::MediaPlayback::Commands::StartOver::Type mRequest;
};

/*
 * Command Previous
 */
class MediaPlaybackPrevious : public ClusterCommand
{
public:
    MediaPlaybackPrevious(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("previous", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaPlayback::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaPlayback::Commands::Previous::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaPlayback::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaPlayback::Commands::Previous::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::MediaPlayback::Commands::Previous::Type mRequest;
};

/*
 * Command Next
 */
class MediaPlaybackNext : public ClusterCommand
{
public:
    MediaPlaybackNext(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("next", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaPlayback::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaPlayback::Commands::Next::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaPlayback::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaPlayback::Commands::Next::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::MediaPlayback::Commands::Next::Type mRequest;
};

/*
 * Command Rewind
 */
class MediaPlaybackRewind : public ClusterCommand
{
public:
    MediaPlaybackRewind(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("rewind", credsIssuerConfig)
    {
        AddArgument("AudioAdvanceUnmuted", 0, 1, &mRequest.audioAdvanceUnmuted);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaPlayback::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaPlayback::Commands::Rewind::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaPlayback::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaPlayback::Commands::Rewind::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::MediaPlayback::Commands::Rewind::Type mRequest;
};

/*
 * Command FastForward
 */
class MediaPlaybackFastForward : public ClusterCommand
{
public:
    MediaPlaybackFastForward(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("fast-forward", credsIssuerConfig)
    {
        AddArgument("AudioAdvanceUnmuted", 0, 1, &mRequest.audioAdvanceUnmuted);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaPlayback::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaPlayback::Commands::FastForward::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaPlayback::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaPlayback::Commands::FastForward::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::MediaPlayback::Commands::FastForward::Type mRequest;
};

/*
 * Command SkipForward
 */
class MediaPlaybackSkipForward : public ClusterCommand
{
public:
    MediaPlaybackSkipForward(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("skip-forward", credsIssuerConfig)
    {
        AddArgument("DeltaPositionMilliseconds", 0, UINT64_MAX, &mRequest.deltaPositionMilliseconds);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaPlayback::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaPlayback::Commands::SkipForward::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaPlayback::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaPlayback::Commands::SkipForward::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::MediaPlayback::Commands::SkipForward::Type mRequest;
};

/*
 * Command SkipBackward
 */
class MediaPlaybackSkipBackward : public ClusterCommand
{
public:
    MediaPlaybackSkipBackward(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("skip-backward", credsIssuerConfig)
    {
        AddArgument("DeltaPositionMilliseconds", 0, UINT64_MAX, &mRequest.deltaPositionMilliseconds);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaPlayback::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaPlayback::Commands::SkipBackward::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaPlayback::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaPlayback::Commands::SkipBackward::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::MediaPlayback::Commands::SkipBackward::Type mRequest;
};

/*
 * Command Seek
 */
class MediaPlaybackSeek : public ClusterCommand
{
public:
    MediaPlaybackSeek(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("seek", credsIssuerConfig)
    {
        AddArgument("Position", 0, UINT64_MAX, &mRequest.position);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaPlayback::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaPlayback::Commands::Seek::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaPlayback::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaPlayback::Commands::Seek::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::MediaPlayback::Commands::Seek::Type mRequest;
};

/*
 * Command ActivateAudioTrack
 */
class MediaPlaybackActivateAudioTrack : public ClusterCommand
{
public:
    MediaPlaybackActivateAudioTrack(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("activate-audio-track", credsIssuerConfig)
    {
        AddArgument("TrackID", &mRequest.trackID);
        AddArgument("AudioOutputIndex", 0, UINT8_MAX, &mRequest.audioOutputIndex);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaPlayback::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaPlayback::Commands::ActivateAudioTrack::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaPlayback::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaPlayback::Commands::ActivateAudioTrack::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::MediaPlayback::Commands::ActivateAudioTrack::Type mRequest;
};

/*
 * Command ActivateTextTrack
 */
class MediaPlaybackActivateTextTrack : public ClusterCommand
{
public:
    MediaPlaybackActivateTextTrack(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("activate-text-track", credsIssuerConfig)
    {
        AddArgument("TrackID", &mRequest.trackID);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaPlayback::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaPlayback::Commands::ActivateTextTrack::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaPlayback::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaPlayback::Commands::ActivateTextTrack::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::MediaPlayback::Commands::ActivateTextTrack::Type mRequest;
};

/*
 * Command DeactivateTextTrack
 */
class MediaPlaybackDeactivateTextTrack : public ClusterCommand
{
public:
    MediaPlaybackDeactivateTextTrack(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("deactivate-text-track", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaPlayback::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaPlayback::Commands::DeactivateTextTrack::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaPlayback::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaPlayback::Commands::DeactivateTextTrack::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::MediaPlayback::Commands::DeactivateTextTrack::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster MediaInput                                                  | 0x0507 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * SelectInput                                                       |   0x00 |
| * ShowInputStatus                                                   |   0x01 |
| * HideInputStatus                                                   |   0x02 |
| * RenameInput                                                       |   0x03 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * InputList                                                         | 0x0000 |
| * CurrentInput                                                      | 0x0001 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command SelectInput
 */
class MediaInputSelectInput : public ClusterCommand
{
public:
    MediaInputSelectInput(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("select-input", credsIssuerConfig)
    {
        AddArgument("Index", 0, UINT8_MAX, &mRequest.index);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaInput::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaInput::Commands::SelectInput::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaInput::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaInput::Commands::SelectInput::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::MediaInput::Commands::SelectInput::Type mRequest;
};

/*
 * Command ShowInputStatus
 */
class MediaInputShowInputStatus : public ClusterCommand
{
public:
    MediaInputShowInputStatus(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("show-input-status", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaInput::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaInput::Commands::ShowInputStatus::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaInput::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaInput::Commands::ShowInputStatus::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::MediaInput::Commands::ShowInputStatus::Type mRequest;
};

/*
 * Command HideInputStatus
 */
class MediaInputHideInputStatus : public ClusterCommand
{
public:
    MediaInputHideInputStatus(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("hide-input-status", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaInput::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaInput::Commands::HideInputStatus::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaInput::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaInput::Commands::HideInputStatus::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::MediaInput::Commands::HideInputStatus::Type mRequest;
};

/*
 * Command RenameInput
 */
class MediaInputRenameInput : public ClusterCommand
{
public:
    MediaInputRenameInput(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("rename-input", credsIssuerConfig)
    {
        AddArgument("Index", 0, UINT8_MAX, &mRequest.index);
        AddArgument("Name", &mRequest.name);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaInput::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaInput::Commands::RenameInput::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::MediaInput::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::MediaInput::Commands::RenameInput::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::MediaInput::Commands::RenameInput::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster LowPower                                                    | 0x0508 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * Sleep                                                             |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command Sleep
 */
class LowPowerSleep : public ClusterCommand
{
public:
    LowPowerSleep(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("sleep", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::LowPower::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::LowPower::Commands::Sleep::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::LowPower::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::LowPower::Commands::Sleep::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::LowPower::Commands::Sleep::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster KeypadInput                                                 | 0x0509 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * SendKey                                                           |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command SendKey
 */
class KeypadInputSendKey : public ClusterCommand
{
public:
    KeypadInputSendKey(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("send-key", credsIssuerConfig)
    {
        AddArgument("KeyCode", 0, UINT8_MAX, &mRequest.keyCode);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::KeypadInput::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::KeypadInput::Commands::SendKey::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::KeypadInput::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::KeypadInput::Commands::SendKey::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::KeypadInput::Commands::SendKey::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster ContentLauncher                                             | 0x050A |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * LaunchContent                                                     |   0x00 |
| * LaunchURL                                                         |   0x01 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * AcceptHeader                                                      | 0x0000 |
| * SupportedStreamingProtocols                                       | 0x0001 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command LaunchContent
 */
class ContentLauncherLaunchContent : public ClusterCommand
{
public:
    ContentLauncherLaunchContent(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("launch-content", credsIssuerConfig), mComplex_Search(&mRequest.search),
        mComplex_PlaybackPreferences(&mRequest.playbackPreferences)
    {
        AddArgument("Search", &mComplex_Search);
        AddArgument("AutoPlay", 0, 1, &mRequest.autoPlay);
        AddArgument("Data", &mRequest.data);
        AddArgument("PlaybackPreferences", &mComplex_PlaybackPreferences, "", Argument::kOptional);
        AddArgument("UseCurrentContext", 0, 1, &mRequest.useCurrentContext);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ContentLauncher::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ContentLauncher::Commands::LaunchContent::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ContentLauncher::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ContentLauncher::Commands::LaunchContent::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ContentLauncher::Commands::LaunchContent::Type mRequest;
    TypedComplexArgument<chip::app::Clusters::ContentLauncher::Structs::ContentSearchStruct::Type> mComplex_Search;
    TypedComplexArgument<chip::Optional<chip::app::Clusters::ContentLauncher::Structs::PlaybackPreferencesStruct::Type>>
        mComplex_PlaybackPreferences;
};

/*
 * Command LaunchURL
 */
class ContentLauncherLaunchURL : public ClusterCommand
{
public:
    ContentLauncherLaunchURL(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("launch-url", credsIssuerConfig), mComplex_BrandingInformation(&mRequest.brandingInformation)
    {
        AddArgument("ContentURL", &mRequest.contentURL);
        AddArgument("DisplayString", &mRequest.displayString);
        AddArgument("BrandingInformation", &mComplex_BrandingInformation, "", Argument::kOptional);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ContentLauncher::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ContentLauncher::Commands::LaunchURL::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ContentLauncher::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ContentLauncher::Commands::LaunchURL::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ContentLauncher::Commands::LaunchURL::Type mRequest;
    TypedComplexArgument<chip::Optional<chip::app::Clusters::ContentLauncher::Structs::BrandingInformationStruct::Type>>
        mComplex_BrandingInformation;
};

/*----------------------------------------------------------------------------*\
| Cluster AudioOutput                                                 | 0x050B |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * SelectOutput                                                      |   0x00 |
| * RenameOutput                                                      |   0x01 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * OutputList                                                        | 0x0000 |
| * CurrentOutput                                                     | 0x0001 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command SelectOutput
 */
class AudioOutputSelectOutput : public ClusterCommand
{
public:
    AudioOutputSelectOutput(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("select-output", credsIssuerConfig)
    {
        AddArgument("Index", 0, UINT8_MAX, &mRequest.index);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::AudioOutput::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::AudioOutput::Commands::SelectOutput::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::AudioOutput::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::AudioOutput::Commands::SelectOutput::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::AudioOutput::Commands::SelectOutput::Type mRequest;
};

/*
 * Command RenameOutput
 */
class AudioOutputRenameOutput : public ClusterCommand
{
public:
    AudioOutputRenameOutput(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("rename-output", credsIssuerConfig)
    {
        AddArgument("Index", 0, UINT8_MAX, &mRequest.index);
        AddArgument("Name", &mRequest.name);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::AudioOutput::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::AudioOutput::Commands::RenameOutput::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::AudioOutput::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::AudioOutput::Commands::RenameOutput::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::AudioOutput::Commands::RenameOutput::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster ApplicationLauncher                                         | 0x050C |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * LaunchApp                                                         |   0x00 |
| * StopApp                                                           |   0x01 |
| * HideApp                                                           |   0x02 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * CatalogList                                                       | 0x0000 |
| * CurrentApp                                                        | 0x0001 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command LaunchApp
 */
class ApplicationLauncherLaunchApp : public ClusterCommand
{
public:
    ApplicationLauncherLaunchApp(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("launch-app", credsIssuerConfig), mComplex_Application(&mRequest.application)
    {
        AddArgument("Application", &mComplex_Application, "", Argument::kOptional);
        AddArgument("Data", &mRequest.data);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ApplicationLauncher::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ApplicationLauncher::Commands::LaunchApp::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ApplicationLauncher::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ApplicationLauncher::Commands::LaunchApp::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ApplicationLauncher::Commands::LaunchApp::Type mRequest;
    TypedComplexArgument<chip::Optional<chip::app::Clusters::ApplicationLauncher::Structs::ApplicationStruct::Type>>
        mComplex_Application;
};

/*
 * Command StopApp
 */
class ApplicationLauncherStopApp : public ClusterCommand
{
public:
    ApplicationLauncherStopApp(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("stop-app", credsIssuerConfig), mComplex_Application(&mRequest.application)
    {
        AddArgument("Application", &mComplex_Application, "", Argument::kOptional);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ApplicationLauncher::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ApplicationLauncher::Commands::StopApp::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ApplicationLauncher::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ApplicationLauncher::Commands::StopApp::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ApplicationLauncher::Commands::StopApp::Type mRequest;
    TypedComplexArgument<chip::Optional<chip::app::Clusters::ApplicationLauncher::Structs::ApplicationStruct::Type>>
        mComplex_Application;
};

/*
 * Command HideApp
 */
class ApplicationLauncherHideApp : public ClusterCommand
{
public:
    ApplicationLauncherHideApp(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("hide-app", credsIssuerConfig), mComplex_Application(&mRequest.application)
    {
        AddArgument("Application", &mComplex_Application, "", Argument::kOptional);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ApplicationLauncher::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ApplicationLauncher::Commands::HideApp::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ApplicationLauncher::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ApplicationLauncher::Commands::HideApp::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ApplicationLauncher::Commands::HideApp::Type mRequest;
    TypedComplexArgument<chip::Optional<chip::app::Clusters::ApplicationLauncher::Structs::ApplicationStruct::Type>>
        mComplex_Application;
};

/*----------------------------------------------------------------------------*\
| Cluster ApplicationBasic                                            | 0x050D |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * VendorName                                                        | 0x0000 |
| * VendorID                                                          | 0x0001 |
| * ApplicationName                                                   | 0x0002 |
| * ProductID                                                         | 0x0003 |
| * Application                                                       | 0x0004 |
| * Status                                                            | 0x0005 |
| * ApplicationVersion                                                | 0x0006 |
| * AllowedVendorList                                                 | 0x0007 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster AccountLogin                                                | 0x050E |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * GetSetupPIN                                                       |   0x00 |
| * Login                                                             |   0x02 |
| * Logout                                                            |   0x03 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * LoggedOut                                                         | 0x0000 |
\*----------------------------------------------------------------------------*/

/*
 * Command GetSetupPIN
 */
class AccountLoginGetSetupPIN : public ClusterCommand
{
public:
    AccountLoginGetSetupPIN(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("get-setup-pin", credsIssuerConfig)
    {
        AddArgument("TempAccountIdentifier", &mRequest.tempAccountIdentifier);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::AccountLogin::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::AccountLogin::Commands::GetSetupPIN::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::AccountLogin::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::AccountLogin::Commands::GetSetupPIN::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::AccountLogin::Commands::GetSetupPIN::Type mRequest;
};

/*
 * Command Login
 */
class AccountLoginLogin : public ClusterCommand
{
public:
    AccountLoginLogin(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("login", credsIssuerConfig)
    {
        AddArgument("TempAccountIdentifier", &mRequest.tempAccountIdentifier);
        AddArgument("SetupPIN", &mRequest.setupPIN);
        AddArgument("Node", 0, UINT64_MAX, &mRequest.node);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::AccountLogin::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::AccountLogin::Commands::Login::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::AccountLogin::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::AccountLogin::Commands::Login::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::AccountLogin::Commands::Login::Type mRequest;
};

/*
 * Command Logout
 */
class AccountLoginLogout : public ClusterCommand
{
public:
    AccountLoginLogout(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("logout", credsIssuerConfig)
    {
        AddArgument("Node", 0, UINT64_MAX, &mRequest.node);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::AccountLogin::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::AccountLogin::Commands::Logout::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::AccountLogin::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::AccountLogin::Commands::Logout::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::AccountLogin::Commands::Logout::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster ContentControl                                              | 0x050F |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * UpdatePIN                                                         |   0x00 |
| * ResetPIN                                                          |   0x01 |
| * Enable                                                            |   0x03 |
| * Disable                                                           |   0x04 |
| * AddBonusTime                                                      |   0x05 |
| * SetScreenDailyTime                                                |   0x06 |
| * BlockUnratedContent                                               |   0x07 |
| * UnblockUnratedContent                                             |   0x08 |
| * SetOnDemandRatingThreshold                                        |   0x09 |
| * SetScheduledContentRatingThreshold                                |   0x0A |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * Enabled                                                           | 0x0000 |
| * OnDemandRatings                                                   | 0x0001 |
| * OnDemandRatingThreshold                                           | 0x0002 |
| * ScheduledContentRatings                                           | 0x0003 |
| * ScheduledContentRatingThreshold                                   | 0x0004 |
| * ScreenDailyTime                                                   | 0x0005 |
| * RemainingScreenTime                                               | 0x0006 |
| * BlockUnrated                                                      | 0x0007 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * RemainingScreenTimeExpired                                        | 0x0000 |
\*----------------------------------------------------------------------------*/

/*
 * Command UpdatePIN
 */
class ContentControlUpdatePIN : public ClusterCommand
{
public:
    ContentControlUpdatePIN(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("update-pin", credsIssuerConfig)
    {
        AddArgument("OldPIN", &mRequest.oldPIN);
        AddArgument("NewPIN", &mRequest.newPIN);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ContentControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ContentControl::Commands::UpdatePIN::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ContentControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ContentControl::Commands::UpdatePIN::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ContentControl::Commands::UpdatePIN::Type mRequest;
};

/*
 * Command ResetPIN
 */
class ContentControlResetPIN : public ClusterCommand
{
public:
    ContentControlResetPIN(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("reset-pin", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ContentControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ContentControl::Commands::ResetPIN::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ContentControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ContentControl::Commands::ResetPIN::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ContentControl::Commands::ResetPIN::Type mRequest;
};

/*
 * Command Enable
 */
class ContentControlEnable : public ClusterCommand
{
public:
    ContentControlEnable(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("enable", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ContentControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ContentControl::Commands::Enable::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ContentControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ContentControl::Commands::Enable::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ContentControl::Commands::Enable::Type mRequest;
};

/*
 * Command Disable
 */
class ContentControlDisable : public ClusterCommand
{
public:
    ContentControlDisable(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("disable", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ContentControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ContentControl::Commands::Disable::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ContentControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ContentControl::Commands::Disable::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ContentControl::Commands::Disable::Type mRequest;
};

/*
 * Command AddBonusTime
 */
class ContentControlAddBonusTime : public ClusterCommand
{
public:
    ContentControlAddBonusTime(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("add-bonus-time", credsIssuerConfig)
    {
        AddArgument("PINCode", &mRequest.PINCode);
        AddArgument("BonusTime", 0, UINT32_MAX, &mRequest.bonusTime);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ContentControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ContentControl::Commands::AddBonusTime::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ContentControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ContentControl::Commands::AddBonusTime::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ContentControl::Commands::AddBonusTime::Type mRequest;
};

/*
 * Command SetScreenDailyTime
 */
class ContentControlSetScreenDailyTime : public ClusterCommand
{
public:
    ContentControlSetScreenDailyTime(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("set-screen-daily-time", credsIssuerConfig)
    {
        AddArgument("ScreenTime", 0, UINT32_MAX, &mRequest.screenTime);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ContentControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ContentControl::Commands::SetScreenDailyTime::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ContentControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ContentControl::Commands::SetScreenDailyTime::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ContentControl::Commands::SetScreenDailyTime::Type mRequest;
};

/*
 * Command BlockUnratedContent
 */
class ContentControlBlockUnratedContent : public ClusterCommand
{
public:
    ContentControlBlockUnratedContent(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("block-unrated-content", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ContentControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ContentControl::Commands::BlockUnratedContent::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ContentControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ContentControl::Commands::BlockUnratedContent::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ContentControl::Commands::BlockUnratedContent::Type mRequest;
};

/*
 * Command UnblockUnratedContent
 */
class ContentControlUnblockUnratedContent : public ClusterCommand
{
public:
    ContentControlUnblockUnratedContent(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("unblock-unrated-content", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ContentControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ContentControl::Commands::UnblockUnratedContent::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ContentControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ContentControl::Commands::UnblockUnratedContent::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ContentControl::Commands::UnblockUnratedContent::Type mRequest;
};

/*
 * Command SetOnDemandRatingThreshold
 */
class ContentControlSetOnDemandRatingThreshold : public ClusterCommand
{
public:
    ContentControlSetOnDemandRatingThreshold(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("set-on-demand-rating-threshold", credsIssuerConfig)
    {
        AddArgument("Rating", &mRequest.rating);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ContentControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ContentControl::Commands::SetOnDemandRatingThreshold::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ContentControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ContentControl::Commands::SetOnDemandRatingThreshold::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ContentControl::Commands::SetOnDemandRatingThreshold::Type mRequest;
};

/*
 * Command SetScheduledContentRatingThreshold
 */
class ContentControlSetScheduledContentRatingThreshold : public ClusterCommand
{
public:
    ContentControlSetScheduledContentRatingThreshold(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("set-scheduled-content-rating-threshold", credsIssuerConfig)
    {
        AddArgument("Rating", &mRequest.rating);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ContentControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ContentControl::Commands::SetScheduledContentRatingThreshold::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ContentControl::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ContentControl::Commands::SetScheduledContentRatingThreshold::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ContentControl::Commands::SetScheduledContentRatingThreshold::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster ContentAppObserver                                          | 0x0510 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * ContentAppMessage                                                 |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command ContentAppMessage
 */
class ContentAppObserverContentAppMessage : public ClusterCommand
{
public:
    ContentAppObserverContentAppMessage(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("content-app-message", credsIssuerConfig)
    {
        AddArgument("Data", &mRequest.data);
        AddArgument("EncodingHint", &mRequest.encodingHint);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ContentAppObserver::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ContentAppObserver::Commands::ContentAppMessage::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ContentAppObserver::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ContentAppObserver::Commands::ContentAppMessage::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ContentAppObserver::Commands::ContentAppMessage::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster ElectricalMeasurement                                       | 0x0B04 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * GetProfileInfoCommand                                             |   0x00 |
| * GetMeasurementProfileCommand                                      |   0x01 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * MeasurementType                                                   | 0x0000 |
| * DcVoltage                                                         | 0x0100 |
| * DcVoltageMin                                                      | 0x0101 |
| * DcVoltageMax                                                      | 0x0102 |
| * DcCurrent                                                         | 0x0103 |
| * DcCurrentMin                                                      | 0x0104 |
| * DcCurrentMax                                                      | 0x0105 |
| * DcPower                                                           | 0x0106 |
| * DcPowerMin                                                        | 0x0107 |
| * DcPowerMax                                                        | 0x0108 |
| * DcVoltageMultiplier                                               | 0x0200 |
| * DcVoltageDivisor                                                  | 0x0201 |
| * DcCurrentMultiplier                                               | 0x0202 |
| * DcCurrentDivisor                                                  | 0x0203 |
| * DcPowerMultiplier                                                 | 0x0204 |
| * DcPowerDivisor                                                    | 0x0205 |
| * AcFrequency                                                       | 0x0300 |
| * AcFrequencyMin                                                    | 0x0301 |
| * AcFrequencyMax                                                    | 0x0302 |
| * NeutralCurrent                                                    | 0x0303 |
| * TotalActivePower                                                  | 0x0304 |
| * TotalReactivePower                                                | 0x0305 |
| * TotalApparentPower                                                | 0x0306 |
| * Measured1stHarmonicCurrent                                        | 0x0307 |
| * Measured3rdHarmonicCurrent                                        | 0x0308 |
| * Measured5thHarmonicCurrent                                        | 0x0309 |
| * Measured7thHarmonicCurrent                                        | 0x030A |
| * Measured9thHarmonicCurrent                                        | 0x030B |
| * Measured11thHarmonicCurrent                                       | 0x030C |
| * MeasuredPhase1stHarmonicCurrent                                   | 0x030D |
| * MeasuredPhase3rdHarmonicCurrent                                   | 0x030E |
| * MeasuredPhase5thHarmonicCurrent                                   | 0x030F |
| * MeasuredPhase7thHarmonicCurrent                                   | 0x0310 |
| * MeasuredPhase9thHarmonicCurrent                                   | 0x0311 |
| * MeasuredPhase11thHarmonicCurrent                                  | 0x0312 |
| * AcFrequencyMultiplier                                             | 0x0400 |
| * AcFrequencyDivisor                                                | 0x0401 |
| * PowerMultiplier                                                   | 0x0402 |
| * PowerDivisor                                                      | 0x0403 |
| * HarmonicCurrentMultiplier                                         | 0x0404 |
| * PhaseHarmonicCurrentMultiplier                                    | 0x0405 |
| * InstantaneousVoltage                                              | 0x0500 |
| * InstantaneousLineCurrent                                          | 0x0501 |
| * InstantaneousActiveCurrent                                        | 0x0502 |
| * InstantaneousReactiveCurrent                                      | 0x0503 |
| * InstantaneousPower                                                | 0x0504 |
| * RmsVoltage                                                        | 0x0505 |
| * RmsVoltageMin                                                     | 0x0506 |
| * RmsVoltageMax                                                     | 0x0507 |
| * RmsCurrent                                                        | 0x0508 |
| * RmsCurrentMin                                                     | 0x0509 |
| * RmsCurrentMax                                                     | 0x050A |
| * ActivePower                                                       | 0x050B |
| * ActivePowerMin                                                    | 0x050C |
| * ActivePowerMax                                                    | 0x050D |
| * ReactivePower                                                     | 0x050E |
| * ApparentPower                                                     | 0x050F |
| * PowerFactor                                                       | 0x0510 |
| * AverageRmsVoltageMeasurementPeriod                                | 0x0511 |
| * AverageRmsUnderVoltageCounter                                     | 0x0513 |
| * RmsExtremeOverVoltagePeriod                                       | 0x0514 |
| * RmsExtremeUnderVoltagePeriod                                      | 0x0515 |
| * RmsVoltageSagPeriod                                               | 0x0516 |
| * RmsVoltageSwellPeriod                                             | 0x0517 |
| * AcVoltageMultiplier                                               | 0x0600 |
| * AcVoltageDivisor                                                  | 0x0601 |
| * AcCurrentMultiplier                                               | 0x0602 |
| * AcCurrentDivisor                                                  | 0x0603 |
| * AcPowerMultiplier                                                 | 0x0604 |
| * AcPowerDivisor                                                    | 0x0605 |
| * OverloadAlarmsMask                                                | 0x0700 |
| * VoltageOverload                                                   | 0x0701 |
| * CurrentOverload                                                   | 0x0702 |
| * AcOverloadAlarmsMask                                              | 0x0800 |
| * AcVoltageOverload                                                 | 0x0801 |
| * AcCurrentOverload                                                 | 0x0802 |
| * AcActivePowerOverload                                             | 0x0803 |
| * AcReactivePowerOverload                                           | 0x0804 |
| * AverageRmsOverVoltage                                             | 0x0805 |
| * AverageRmsUnderVoltage                                            | 0x0806 |
| * RmsExtremeOverVoltage                                             | 0x0807 |
| * RmsExtremeUnderVoltage                                            | 0x0808 |
| * RmsVoltageSag                                                     | 0x0809 |
| * RmsVoltageSwell                                                   | 0x080A |
| * LineCurrentPhaseB                                                 | 0x0901 |
| * ActiveCurrentPhaseB                                               | 0x0902 |
| * ReactiveCurrentPhaseB                                             | 0x0903 |
| * RmsVoltagePhaseB                                                  | 0x0905 |
| * RmsVoltageMinPhaseB                                               | 0x0906 |
| * RmsVoltageMaxPhaseB                                               | 0x0907 |
| * RmsCurrentPhaseB                                                  | 0x0908 |
| * RmsCurrentMinPhaseB                                               | 0x0909 |
| * RmsCurrentMaxPhaseB                                               | 0x090A |
| * ActivePowerPhaseB                                                 | 0x090B |
| * ActivePowerMinPhaseB                                              | 0x090C |
| * ActivePowerMaxPhaseB                                              | 0x090D |
| * ReactivePowerPhaseB                                               | 0x090E |
| * ApparentPowerPhaseB                                               | 0x090F |
| * PowerFactorPhaseB                                                 | 0x0910 |
| * AverageRmsVoltageMeasurementPeriodPhaseB                          | 0x0911 |
| * AverageRmsOverVoltageCounterPhaseB                                | 0x0912 |
| * AverageRmsUnderVoltageCounterPhaseB                               | 0x0913 |
| * RmsExtremeOverVoltagePeriodPhaseB                                 | 0x0914 |
| * RmsExtremeUnderVoltagePeriodPhaseB                                | 0x0915 |
| * RmsVoltageSagPeriodPhaseB                                         | 0x0916 |
| * RmsVoltageSwellPeriodPhaseB                                       | 0x0917 |
| * LineCurrentPhaseC                                                 | 0x0A01 |
| * ActiveCurrentPhaseC                                               | 0x0A02 |
| * ReactiveCurrentPhaseC                                             | 0x0A03 |
| * RmsVoltagePhaseC                                                  | 0x0A05 |
| * RmsVoltageMinPhaseC                                               | 0x0A06 |
| * RmsVoltageMaxPhaseC                                               | 0x0A07 |
| * RmsCurrentPhaseC                                                  | 0x0A08 |
| * RmsCurrentMinPhaseC                                               | 0x0A09 |
| * RmsCurrentMaxPhaseC                                               | 0x0A0A |
| * ActivePowerPhaseC                                                 | 0x0A0B |
| * ActivePowerMinPhaseC                                              | 0x0A0C |
| * ActivePowerMaxPhaseC                                              | 0x0A0D |
| * ReactivePowerPhaseC                                               | 0x0A0E |
| * ApparentPowerPhaseC                                               | 0x0A0F |
| * PowerFactorPhaseC                                                 | 0x0A10 |
| * AverageRmsVoltageMeasurementPeriodPhaseC                          | 0x0A11 |
| * AverageRmsOverVoltageCounterPhaseC                                | 0x0A12 |
| * AverageRmsUnderVoltageCounterPhaseC                               | 0x0A13 |
| * RmsExtremeOverVoltagePeriodPhaseC                                 | 0x0A14 |
| * RmsExtremeUnderVoltagePeriodPhaseC                                | 0x0A15 |
| * RmsVoltageSagPeriodPhaseC                                         | 0x0A16 |
| * RmsVoltageSwellPeriodPhaseC                                       | 0x0A17 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command GetProfileInfoCommand
 */
class ElectricalMeasurementGetProfileInfoCommand : public ClusterCommand
{
public:
    ElectricalMeasurementGetProfileInfoCommand(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("get-profile-info-command", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ElectricalMeasurement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ElectricalMeasurement::Commands::GetProfileInfoCommand::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ElectricalMeasurement::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::ElectricalMeasurement::Commands::GetProfileInfoCommand::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ElectricalMeasurement::Commands::GetProfileInfoCommand::Type mRequest;
};

/*
 * Command GetMeasurementProfileCommand
 */
class ElectricalMeasurementGetMeasurementProfileCommand : public ClusterCommand
{
public:
    ElectricalMeasurementGetMeasurementProfileCommand(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("get-measurement-profile-command", credsIssuerConfig)
    {
        AddArgument("AttributeId", 0, UINT16_MAX, &mRequest.attributeId);
        AddArgument("StartTime", 0, UINT32_MAX, &mRequest.startTime);
        AddArgument("NumberOfIntervals", 0, UINT8_MAX, &mRequest.numberOfIntervals);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ElectricalMeasurement::Id;
        constexpr chip::CommandId commandId =
            chip::app::Clusters::ElectricalMeasurement::Commands::GetMeasurementProfileCommand::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::ElectricalMeasurement::Id;
        constexpr chip::CommandId commandId =
            chip::app::Clusters::ElectricalMeasurement::Commands::GetMeasurementProfileCommand::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::ElectricalMeasurement::Commands::GetMeasurementProfileCommand::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster UnitTesting                                                 | 0xFFF1FC05 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * Test                                                              |   0x00 |
| * TestNotHandled                                                    |   0x01 |
| * TestSpecific                                                      |   0x02 |
| * TestUnknownCommand                                                |   0x03 |
| * TestAddArguments                                                  |   0x04 |
| * TestSimpleArgumentRequest                                         |   0x05 |
| * TestStructArrayArgumentRequest                                    |   0x06 |
| * TestStructArgumentRequest                                         |   0x07 |
| * TestNestedStructArgumentRequest                                   |   0x08 |
| * TestListStructArgumentRequest                                     |   0x09 |
| * TestListInt8UArgumentRequest                                      |   0x0A |
| * TestNestedStructListArgumentRequest                               |   0x0B |
| * TestListNestedStructListArgumentRequest                           |   0x0C |
| * TestListInt8UReverseRequest                                       |   0x0D |
| * TestEnumsRequest                                                  |   0x0E |
| * TestNullableOptionalRequest                                       |   0x0F |
| * TestComplexNullableOptionalRequest                                |   0x10 |
| * SimpleStructEchoRequest                                           |   0x11 |
| * TimedInvokeRequest                                                |   0x12 |
| * TestSimpleOptionalArgumentRequest                                 |   0x13 |
| * TestEmitTestEventRequest                                          |   0x14 |
| * TestEmitTestFabricScopedEventRequest                              |   0x15 |
| * TestBatchHelperRequest                                            |   0x16 |
| * TestSecondBatchHelperRequest                                      |   0x17 |
| * TestDifferentVendorMeiRequest                                     |   0xFFF200AA|
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * Boolean                                                           | 0x0000 |
| * Bitmap8                                                           | 0x0001 |
| * Bitmap16                                                          | 0x0002 |
| * Bitmap32                                                          | 0x0003 |
| * Bitmap64                                                          | 0x0004 |
| * Int8u                                                             | 0x0005 |
| * Int16u                                                            | 0x0006 |
| * Int24u                                                            | 0x0007 |
| * Int32u                                                            | 0x0008 |
| * Int40u                                                            | 0x0009 |
| * Int48u                                                            | 0x000A |
| * Int56u                                                            | 0x000B |
| * Int64u                                                            | 0x000C |
| * Int8s                                                             | 0x000D |
| * Int16s                                                            | 0x000E |
| * Int24s                                                            | 0x000F |
| * Int32s                                                            | 0x0010 |
| * Int40s                                                            | 0x0011 |
| * Int48s                                                            | 0x0012 |
| * Int56s                                                            | 0x0013 |
| * Int64s                                                            | 0x0014 |
| * Enum8                                                             | 0x0015 |
| * Enum16                                                            | 0x0016 |
| * FloatSingle                                                       | 0x0017 |
| * FloatDouble                                                       | 0x0018 |
| * OctetString                                                       | 0x0019 |
| * ListInt8u                                                         | 0x001A |
| * ListOctetString                                                   | 0x001B |
| * ListStructOctetString                                             | 0x001C |
| * LongOctetString                                                   | 0x001D |
| * CharString                                                        | 0x001E |
| * LongCharString                                                    | 0x001F |
| * EpochUs                                                           | 0x0020 |
| * EpochS                                                            | 0x0021 |
| * VendorId                                                          | 0x0022 |
| * ListNullablesAndOptionalsStruct                                   | 0x0023 |
| * EnumAttr                                                          | 0x0024 |
| * StructAttr                                                        | 0x0025 |
| * RangeRestrictedInt8u                                              | 0x0026 |
| * RangeRestrictedInt8s                                              | 0x0027 |
| * RangeRestrictedInt16u                                             | 0x0028 |
| * RangeRestrictedInt16s                                             | 0x0029 |
| * ListLongOctetString                                               | 0x002A |
| * ListFabricScoped                                                  | 0x002B |
| * TimedWriteBoolean                                                 | 0x0030 |
| * GeneralErrorBoolean                                               | 0x0031 |
| * ClusterErrorBoolean                                               | 0x0032 |
| * Unsupported                                                       | 0x00FF |
| * NullableBoolean                                                   | 0x4000 |
| * NullableBitmap8                                                   | 0x4001 |
| * NullableBitmap16                                                  | 0x4002 |
| * NullableBitmap32                                                  | 0x4003 |
| * NullableBitmap64                                                  | 0x4004 |
| * NullableInt8u                                                     | 0x4005 |
| * NullableInt16u                                                    | 0x4006 |
| * NullableInt24u                                                    | 0x4007 |
| * NullableInt32u                                                    | 0x4008 |
| * NullableInt40u                                                    | 0x4009 |
| * NullableInt48u                                                    | 0x400A |
| * NullableInt56u                                                    | 0x400B |
| * NullableInt64u                                                    | 0x400C |
| * NullableInt8s                                                     | 0x400D |
| * NullableInt16s                                                    | 0x400E |
| * NullableInt24s                                                    | 0x400F |
| * NullableInt32s                                                    | 0x4010 |
| * NullableInt40s                                                    | 0x4011 |
| * NullableInt48s                                                    | 0x4012 |
| * NullableInt56s                                                    | 0x4013 |
| * NullableInt64s                                                    | 0x4014 |
| * NullableEnum8                                                     | 0x4015 |
| * NullableEnum16                                                    | 0x4016 |
| * NullableFloatSingle                                               | 0x4017 |
| * NullableFloatDouble                                               | 0x4018 |
| * NullableOctetString                                               | 0x4019 |
| * NullableCharString                                                | 0x401E |
| * NullableEnumAttr                                                  | 0x4024 |
| * NullableStruct                                                    | 0x4025 |
| * NullableRangeRestrictedInt8u                                      | 0x4026 |
| * NullableRangeRestrictedInt8s                                      | 0x4027 |
| * NullableRangeRestrictedInt16u                                     | 0x4028 |
| * NullableRangeRestrictedInt16s                                     | 0x4029 |
| * WriteOnlyInt8u                                                    | 0x402A |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
| * MeiInt8u                                                          | 0xFFF24F01|
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * TestEvent                                                         | 0x0001 |
| * TestFabricScopedEvent                                             | 0x0002 |
| * TestDifferentVendorMeiEvent                                       | 0xFFF200EE|
\*----------------------------------------------------------------------------*/

/*
 * Command Test
 */
class UnitTestingTest : public ClusterCommand
{
public:
    UnitTestingTest(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("test", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::Test::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::Test::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::UnitTesting::Commands::Test::Type mRequest;
};

/*
 * Command TestNotHandled
 */
class UnitTestingTestNotHandled : public ClusterCommand
{
public:
    UnitTestingTestNotHandled(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("test-not-handled", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestNotHandled::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestNotHandled::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::UnitTesting::Commands::TestNotHandled::Type mRequest;
};

/*
 * Command TestSpecific
 */
class UnitTestingTestSpecific : public ClusterCommand
{
public:
    UnitTestingTestSpecific(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("test-specific", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestSpecific::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestSpecific::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::UnitTesting::Commands::TestSpecific::Type mRequest;
};

/*
 * Command TestUnknownCommand
 */
class UnitTestingTestUnknownCommand : public ClusterCommand
{
public:
    UnitTestingTestUnknownCommand(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("test-unknown-command", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestUnknownCommand::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestUnknownCommand::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::UnitTesting::Commands::TestUnknownCommand::Type mRequest;
};

/*
 * Command TestAddArguments
 */
class UnitTestingTestAddArguments : public ClusterCommand
{
public:
    UnitTestingTestAddArguments(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("test-add-arguments", credsIssuerConfig)
    {
        AddArgument("Arg1", 0, UINT8_MAX, &mRequest.arg1);
        AddArgument("Arg2", 0, UINT8_MAX, &mRequest.arg2);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestAddArguments::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestAddArguments::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::UnitTesting::Commands::TestAddArguments::Type mRequest;
};

/*
 * Command TestSimpleArgumentRequest
 */
class UnitTestingTestSimpleArgumentRequest : public ClusterCommand
{
public:
    UnitTestingTestSimpleArgumentRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("test-simple-argument-request", credsIssuerConfig)
    {
        AddArgument("Arg1", 0, 1, &mRequest.arg1);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestSimpleArgumentRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestSimpleArgumentRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::UnitTesting::Commands::TestSimpleArgumentRequest::Type mRequest;
};

/*
 * Command TestStructArrayArgumentRequest
 */
class UnitTestingTestStructArrayArgumentRequest : public ClusterCommand
{
public:
    UnitTestingTestStructArrayArgumentRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("test-struct-array-argument-request", credsIssuerConfig), mComplex_Arg1(&mRequest.arg1),
        mComplex_Arg2(&mRequest.arg2), mComplex_Arg3(&mRequest.arg3), mComplex_Arg4(&mRequest.arg4)
    {
        AddArgument("Arg1", &mComplex_Arg1);
        AddArgument("Arg2", &mComplex_Arg2);
        AddArgument("Arg3", &mComplex_Arg3);
        AddArgument("Arg4", &mComplex_Arg4);
        AddArgument("Arg5", 0, UINT8_MAX, &mRequest.arg5);
        AddArgument("Arg6", 0, 1, &mRequest.arg6);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestStructArrayArgumentRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestStructArrayArgumentRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::UnitTesting::Commands::TestStructArrayArgumentRequest::Type mRequest;
    TypedComplexArgument<chip::app::DataModel::List<const chip::app::Clusters::UnitTesting::Structs::NestedStructList::Type>>
        mComplex_Arg1;
    TypedComplexArgument<chip::app::DataModel::List<const chip::app::Clusters::UnitTesting::Structs::SimpleStruct::Type>>
        mComplex_Arg2;
    TypedComplexArgument<chip::app::DataModel::List<const chip::app::Clusters::UnitTesting::SimpleEnum>> mComplex_Arg3;
    TypedComplexArgument<chip::app::DataModel::List<const bool>> mComplex_Arg4;
};

/*
 * Command TestStructArgumentRequest
 */
class UnitTestingTestStructArgumentRequest : public ClusterCommand
{
public:
    UnitTestingTestStructArgumentRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("test-struct-argument-request", credsIssuerConfig), mComplex_Arg1(&mRequest.arg1)
    {
        AddArgument("Arg1", &mComplex_Arg1);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestStructArgumentRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestStructArgumentRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::UnitTesting::Commands::TestStructArgumentRequest::Type mRequest;
    TypedComplexArgument<chip::app::Clusters::UnitTesting::Structs::SimpleStruct::Type> mComplex_Arg1;
};

/*
 * Command TestNestedStructArgumentRequest
 */
class UnitTestingTestNestedStructArgumentRequest : public ClusterCommand
{
public:
    UnitTestingTestNestedStructArgumentRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("test-nested-struct-argument-request", credsIssuerConfig), mComplex_Arg1(&mRequest.arg1)
    {
        AddArgument("Arg1", &mComplex_Arg1);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestNestedStructArgumentRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestNestedStructArgumentRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::UnitTesting::Commands::TestNestedStructArgumentRequest::Type mRequest;
    TypedComplexArgument<chip::app::Clusters::UnitTesting::Structs::NestedStruct::Type> mComplex_Arg1;
};

/*
 * Command TestListStructArgumentRequest
 */
class UnitTestingTestListStructArgumentRequest : public ClusterCommand
{
public:
    UnitTestingTestListStructArgumentRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("test-list-struct-argument-request", credsIssuerConfig), mComplex_Arg1(&mRequest.arg1)
    {
        AddArgument("Arg1", &mComplex_Arg1);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestListStructArgumentRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestListStructArgumentRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::UnitTesting::Commands::TestListStructArgumentRequest::Type mRequest;
    TypedComplexArgument<chip::app::DataModel::List<const chip::app::Clusters::UnitTesting::Structs::SimpleStruct::Type>>
        mComplex_Arg1;
};

/*
 * Command TestListInt8UArgumentRequest
 */
class UnitTestingTestListInt8UArgumentRequest : public ClusterCommand
{
public:
    UnitTestingTestListInt8UArgumentRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("test-list-int8uargument-request", credsIssuerConfig), mComplex_Arg1(&mRequest.arg1)
    {
        AddArgument("Arg1", &mComplex_Arg1);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestListInt8UArgumentRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestListInt8UArgumentRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::UnitTesting::Commands::TestListInt8UArgumentRequest::Type mRequest;
    TypedComplexArgument<chip::app::DataModel::List<const uint8_t>> mComplex_Arg1;
};

/*
 * Command TestNestedStructListArgumentRequest
 */
class UnitTestingTestNestedStructListArgumentRequest : public ClusterCommand
{
public:
    UnitTestingTestNestedStructListArgumentRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("test-nested-struct-list-argument-request", credsIssuerConfig), mComplex_Arg1(&mRequest.arg1)
    {
        AddArgument("Arg1", &mComplex_Arg1);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestNestedStructListArgumentRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestNestedStructListArgumentRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::UnitTesting::Commands::TestNestedStructListArgumentRequest::Type mRequest;
    TypedComplexArgument<chip::app::Clusters::UnitTesting::Structs::NestedStructList::Type> mComplex_Arg1;
};

/*
 * Command TestListNestedStructListArgumentRequest
 */
class UnitTestingTestListNestedStructListArgumentRequest : public ClusterCommand
{
public:
    UnitTestingTestListNestedStructListArgumentRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("test-list-nested-struct-list-argument-request", credsIssuerConfig), mComplex_Arg1(&mRequest.arg1)
    {
        AddArgument("Arg1", &mComplex_Arg1);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId =
            chip::app::Clusters::UnitTesting::Commands::TestListNestedStructListArgumentRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId =
            chip::app::Clusters::UnitTesting::Commands::TestListNestedStructListArgumentRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::UnitTesting::Commands::TestListNestedStructListArgumentRequest::Type mRequest;
    TypedComplexArgument<chip::app::DataModel::List<const chip::app::Clusters::UnitTesting::Structs::NestedStructList::Type>>
        mComplex_Arg1;
};

/*
 * Command TestListInt8UReverseRequest
 */
class UnitTestingTestListInt8UReverseRequest : public ClusterCommand
{
public:
    UnitTestingTestListInt8UReverseRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("test-list-int8ureverse-request", credsIssuerConfig), mComplex_Arg1(&mRequest.arg1)
    {
        AddArgument("Arg1", &mComplex_Arg1);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestListInt8UReverseRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestListInt8UReverseRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::UnitTesting::Commands::TestListInt8UReverseRequest::Type mRequest;
    TypedComplexArgument<chip::app::DataModel::List<const uint8_t>> mComplex_Arg1;
};

/*
 * Command TestEnumsRequest
 */
class UnitTestingTestEnumsRequest : public ClusterCommand
{
public:
    UnitTestingTestEnumsRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("test-enums-request", credsIssuerConfig)
    {
        AddArgument("Arg1", 0, UINT16_MAX, &mRequest.arg1);
        AddArgument("Arg2", 0, UINT8_MAX, &mRequest.arg2);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestEnumsRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestEnumsRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::UnitTesting::Commands::TestEnumsRequest::Type mRequest;
};

/*
 * Command TestNullableOptionalRequest
 */
class UnitTestingTestNullableOptionalRequest : public ClusterCommand
{
public:
    UnitTestingTestNullableOptionalRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("test-nullable-optional-request", credsIssuerConfig)
    {
        AddArgument("Arg1", 0, UINT8_MAX, &mRequest.arg1);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestNullableOptionalRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestNullableOptionalRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::UnitTesting::Commands::TestNullableOptionalRequest::Type mRequest;
};

/*
 * Command TestComplexNullableOptionalRequest
 */
class UnitTestingTestComplexNullableOptionalRequest : public ClusterCommand
{
public:
    UnitTestingTestComplexNullableOptionalRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("test-complex-nullable-optional-request", credsIssuerConfig),
        mComplex_NullableStruct(&mRequest.nullableStruct), mComplex_OptionalStruct(&mRequest.optionalStruct),
        mComplex_NullableOptionalStruct(&mRequest.nullableOptionalStruct), mComplex_NullableList(&mRequest.nullableList),
        mComplex_OptionalList(&mRequest.optionalList), mComplex_NullableOptionalList(&mRequest.nullableOptionalList)
    {
        AddArgument("NullableInt", 0, UINT16_MAX, &mRequest.nullableInt);
        AddArgument("OptionalInt", 0, UINT16_MAX, &mRequest.optionalInt);
        AddArgument("NullableOptionalInt", 0, UINT16_MAX, &mRequest.nullableOptionalInt);
        AddArgument("NullableString", &mRequest.nullableString);
        AddArgument("OptionalString", &mRequest.optionalString);
        AddArgument("NullableOptionalString", &mRequest.nullableOptionalString);
        AddArgument("NullableStruct", &mComplex_NullableStruct);
        AddArgument("OptionalStruct", &mComplex_OptionalStruct, "", Argument::kOptional);
        AddArgument("NullableOptionalStruct", &mComplex_NullableOptionalStruct, "", Argument::kOptional);
        AddArgument("NullableList", &mComplex_NullableList);
        AddArgument("OptionalList", &mComplex_OptionalList, "", Argument::kOptional);
        AddArgument("NullableOptionalList", &mComplex_NullableOptionalList, "", Argument::kOptional);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestComplexNullableOptionalRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestComplexNullableOptionalRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::UnitTesting::Commands::TestComplexNullableOptionalRequest::Type mRequest;
    TypedComplexArgument<chip::app::DataModel::Nullable<chip::app::Clusters::UnitTesting::Structs::SimpleStruct::Type>>
        mComplex_NullableStruct;
    TypedComplexArgument<chip::Optional<chip::app::Clusters::UnitTesting::Structs::SimpleStruct::Type>> mComplex_OptionalStruct;
    TypedComplexArgument<
        chip::Optional<chip::app::DataModel::Nullable<chip::app::Clusters::UnitTesting::Structs::SimpleStruct::Type>>>
        mComplex_NullableOptionalStruct;
    TypedComplexArgument<
        chip::app::DataModel::Nullable<chip::app::DataModel::List<const chip::app::Clusters::UnitTesting::SimpleEnum>>>
        mComplex_NullableList;
    TypedComplexArgument<chip::Optional<chip::app::DataModel::List<const chip::app::Clusters::UnitTesting::SimpleEnum>>>
        mComplex_OptionalList;
    TypedComplexArgument<chip::Optional<
        chip::app::DataModel::Nullable<chip::app::DataModel::List<const chip::app::Clusters::UnitTesting::SimpleEnum>>>>
        mComplex_NullableOptionalList;
};

/*
 * Command SimpleStructEchoRequest
 */
class UnitTestingSimpleStructEchoRequest : public ClusterCommand
{
public:
    UnitTestingSimpleStructEchoRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("simple-struct-echo-request", credsIssuerConfig), mComplex_Arg1(&mRequest.arg1)
    {
        AddArgument("Arg1", &mComplex_Arg1);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::SimpleStructEchoRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::SimpleStructEchoRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::UnitTesting::Commands::SimpleStructEchoRequest::Type mRequest;
    TypedComplexArgument<chip::app::Clusters::UnitTesting::Structs::SimpleStruct::Type> mComplex_Arg1;
};

/*
 * Command TimedInvokeRequest
 */
class UnitTestingTimedInvokeRequest : public ClusterCommand
{
public:
    UnitTestingTimedInvokeRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("timed-invoke-request", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TimedInvokeRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TimedInvokeRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::UnitTesting::Commands::TimedInvokeRequest::Type mRequest;
};

/*
 * Command TestSimpleOptionalArgumentRequest
 */
class UnitTestingTestSimpleOptionalArgumentRequest : public ClusterCommand
{
public:
    UnitTestingTestSimpleOptionalArgumentRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("test-simple-optional-argument-request", credsIssuerConfig)
    {
        AddArgument("Arg1", 0, 1, &mRequest.arg1);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestSimpleOptionalArgumentRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestSimpleOptionalArgumentRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::UnitTesting::Commands::TestSimpleOptionalArgumentRequest::Type mRequest;
};

/*
 * Command TestEmitTestEventRequest
 */
class UnitTestingTestEmitTestEventRequest : public ClusterCommand
{
public:
    UnitTestingTestEmitTestEventRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("test-emit-test-event-request", credsIssuerConfig)
    {
        AddArgument("Arg1", 0, UINT8_MAX, &mRequest.arg1);
        AddArgument("Arg2", 0, UINT8_MAX, &mRequest.arg2);
        AddArgument("Arg3", 0, 1, &mRequest.arg3);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestEmitTestEventRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestEmitTestEventRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::UnitTesting::Commands::TestEmitTestEventRequest::Type mRequest;
};

/*
 * Command TestEmitTestFabricScopedEventRequest
 */
class UnitTestingTestEmitTestFabricScopedEventRequest : public ClusterCommand
{
public:
    UnitTestingTestEmitTestFabricScopedEventRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("test-emit-test-fabric-scoped-event-request", credsIssuerConfig)
    {
        AddArgument("Arg1", 0, UINT8_MAX, &mRequest.arg1);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestEmitTestFabricScopedEventRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestEmitTestFabricScopedEventRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::UnitTesting::Commands::TestEmitTestFabricScopedEventRequest::Type mRequest;
};

/*
 * Command TestBatchHelperRequest
 */
class UnitTestingTestBatchHelperRequest : public ClusterCommand
{
public:
    UnitTestingTestBatchHelperRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("test-batch-helper-request", credsIssuerConfig)
    {
        AddArgument("SleepBeforeResponseTimeMs", 0, UINT16_MAX, &mRequest.sleepBeforeResponseTimeMs);
        AddArgument("SizeOfResponseBuffer", 0, UINT16_MAX, &mRequest.sizeOfResponseBuffer);
        AddArgument("FillCharacter", 0, UINT8_MAX, &mRequest.fillCharacter);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestBatchHelperRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestBatchHelperRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::UnitTesting::Commands::TestBatchHelperRequest::Type mRequest;
};

/*
 * Command TestSecondBatchHelperRequest
 */
class UnitTestingTestSecondBatchHelperRequest : public ClusterCommand
{
public:
    UnitTestingTestSecondBatchHelperRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("test-second-batch-helper-request", credsIssuerConfig)
    {
        AddArgument("SleepBeforeResponseTimeMs", 0, UINT16_MAX, &mRequest.sleepBeforeResponseTimeMs);
        AddArgument("SizeOfResponseBuffer", 0, UINT16_MAX, &mRequest.sizeOfResponseBuffer);
        AddArgument("FillCharacter", 0, UINT8_MAX, &mRequest.fillCharacter);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestSecondBatchHelperRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestSecondBatchHelperRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::UnitTesting::Commands::TestSecondBatchHelperRequest::Type mRequest;
};

/*
 * Command TestDifferentVendorMeiRequest
 */
class UnitTestingTestDifferentVendorMeiRequest : public ClusterCommand
{
public:
    UnitTestingTestDifferentVendorMeiRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("test-different-vendor-mei-request", credsIssuerConfig)
    {
        AddArgument("Arg1", 0, UINT8_MAX, &mRequest.arg1);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestDifferentVendorMeiRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::UnitTesting::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::UnitTesting::Commands::TestDifferentVendorMeiRequest::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::UnitTesting::Commands::TestDifferentVendorMeiRequest::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster FaultInjection                                              | 0xFFF1FC06 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * FailAtFault                                                       |   0x00 |
| * FailRandomlyAtFault                                               |   0x01 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command FailAtFault
 */
class FaultInjectionFailAtFault : public ClusterCommand
{
public:
    FaultInjectionFailAtFault(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("fail-at-fault", credsIssuerConfig)
    {
        AddArgument("Type", 0, UINT8_MAX, &mRequest.type);
        AddArgument("Id", 0, UINT32_MAX, &mRequest.id);
        AddArgument("NumCallsToSkip", 0, UINT32_MAX, &mRequest.numCallsToSkip);
        AddArgument("NumCallsToFail", 0, UINT32_MAX, &mRequest.numCallsToFail);
        AddArgument("TakeMutex", 0, 1, &mRequest.takeMutex);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::FaultInjection::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::FaultInjection::Commands::FailAtFault::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::FaultInjection::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::FaultInjection::Commands::FailAtFault::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::FaultInjection::Commands::FailAtFault::Type mRequest;
};

/*
 * Command FailRandomlyAtFault
 */
class FaultInjectionFailRandomlyAtFault : public ClusterCommand
{
public:
    FaultInjectionFailRandomlyAtFault(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("fail-randomly-at-fault", credsIssuerConfig)
    {
        AddArgument("Type", 0, UINT8_MAX, &mRequest.type);
        AddArgument("Id", 0, UINT32_MAX, &mRequest.id);
        AddArgument("Percentage", 0, UINT8_MAX, &mRequest.percentage);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::FaultInjection::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::FaultInjection::Commands::FailRandomlyAtFault::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::FaultInjection::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::FaultInjection::Commands::FailRandomlyAtFault::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::FaultInjection::Commands::FailRandomlyAtFault::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster SampleMei                                                   | 0xFFF1FC20 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * Ping                                                              |   0x00 |
| * AddArguments                                                      |   0x02 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * FlipFlop                                                          | 0x0000 |
| * GeneratedCommandList                                              | 0xFFF8 |
| * AcceptedCommandList                                               | 0xFFF9 |
| * EventList                                                         | 0xFFFA |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * PingCountEvent                                                    | 0x0000 |
\*----------------------------------------------------------------------------*/

/*
 * Command Ping
 */
class SampleMeiPing : public ClusterCommand
{
public:
    SampleMeiPing(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("ping", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleMei::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::SampleMei::Commands::Ping::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleMei::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::SampleMei::Commands::Ping::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::SampleMei::Commands::Ping::Type mRequest;
};

/*
 * Command AddArguments
 */
class SampleMeiAddArguments : public ClusterCommand
{
public:
    SampleMeiAddArguments(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("add-arguments", credsIssuerConfig)
    {
        AddArgument("Arg1", 0, UINT8_MAX, &mRequest.arg1);
        AddArgument("Arg2", 0, UINT8_MAX, &mRequest.arg2);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector<chip::EndpointId> endpointIds) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleMei::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::SampleMei::Commands::AddArguments::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId,
                        commandId, endpointIds.at(0));
        return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest);
    }

    CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override
    {
        constexpr chip::ClusterId clusterId = chip::app::Clusters::SampleMei::Id;
        constexpr chip::CommandId commandId = chip::app::Clusters::SampleMei::Commands::AddArguments::Id;

        ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId,
                        groupId);

        return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest);
    }

private:
    chip::app::Clusters::SampleMei::Commands::AddArguments::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Register all Clusters commands                                               |
\*----------------------------------------------------------------------------*/
void registerClusterIdentify(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::Identify;

    const char * clusterName = "Identify";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),    //
        make_unique<IdentifyIdentify>(credsIssuerConfig),      //
        make_unique<IdentifyTriggerEffect>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "identify-time", Attributes::IdentifyTime::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "identify-type", Attributes::IdentifyType::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<uint16_t>>(Id, "identify-time", 0, UINT16_MAX, Attributes::IdentifyTime::Id,
                                              WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::Identify::IdentifyTypeEnum>>(
            Id, "identify-type", 0, UINT8_MAX, Attributes::IdentifyType::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "identify-time", Attributes::IdentifyTime::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "identify-type", Attributes::IdentifyType::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterGroups(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::Groups;

    const char * clusterName = "Groups";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),          //
        make_unique<GroupsAddGroup>(credsIssuerConfig),              //
        make_unique<GroupsViewGroup>(credsIssuerConfig),             //
        make_unique<GroupsGetGroupMembership>(credsIssuerConfig),    //
        make_unique<GroupsRemoveGroup>(credsIssuerConfig),           //
        make_unique<GroupsRemoveAllGroups>(credsIssuerConfig),       //
        make_unique<GroupsAddGroupIfIdentifying>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "name-support", Attributes::NameSupport::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::Groups::NameSupportBitmap>>>(
            Id, "name-support", 0, UINT8_MAX, Attributes::NameSupport::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "name-support", Attributes::NameSupport::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterOnOff(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::OnOff;

    const char * clusterName = "OnOff";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),           //
        make_unique<OnOffOff>(credsIssuerConfig),                     //
        make_unique<OnOffOn>(credsIssuerConfig),                      //
        make_unique<OnOffToggle>(credsIssuerConfig),                  //
        make_unique<OnOffOffWithEffect>(credsIssuerConfig),           //
        make_unique<OnOffOnWithRecallGlobalScene>(credsIssuerConfig), //
        make_unique<OnOffOnWithTimedOff>(credsIssuerConfig),          //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "on-off", Attributes::OnOff::Id, credsIssuerConfig),                                //
        make_unique<ReadAttribute>(Id, "global-scene-control", Attributes::GlobalSceneControl::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "on-time", Attributes::OnTime::Id, credsIssuerConfig),                              //
        make_unique<ReadAttribute>(Id, "off-wait-time", Attributes::OffWaitTime::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "start-up-on-off", Attributes::StartUpOnOff::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<bool>>(Id, "on-off", 0, 1, Attributes::OnOff::Id, WriteCommandType::kForceWrite,
                                          credsIssuerConfig), //
        make_unique<WriteAttribute<bool>>(Id, "global-scene-control", 0, 1, Attributes::GlobalSceneControl::Id,
                                          WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "on-time", 0, UINT16_MAX, Attributes::OnTime::Id, WriteCommandType::kWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "off-wait-time", 0, UINT16_MAX, Attributes::OffWaitTime::Id,
                                              WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::app::Clusters::OnOff::StartUpOnOffEnum>>>(
            Id, "start-up-on-off", 0, UINT8_MAX, Attributes::StartUpOnOff::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "on-off", Attributes::OnOff::Id, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, "global-scene-control", Attributes::GlobalSceneControl::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "on-time", Attributes::OnTime::Id, credsIssuerConfig),                              //
        make_unique<SubscribeAttribute>(Id, "off-wait-time", Attributes::OffWaitTime::Id, credsIssuerConfig),                   //
        make_unique<SubscribeAttribute>(Id, "start-up-on-off", Attributes::StartUpOnOff::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterOnOffSwitchConfiguration(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::OnOffSwitchConfiguration;

    const char * clusterName = "OnOffSwitchConfiguration";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "switch-type", Attributes::SwitchType::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "switch-actions", Attributes::SwitchActions::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<uint8_t>>(Id, "switch-type", 0, UINT8_MAX, Attributes::SwitchType::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "switch-actions", 0, UINT8_MAX, Attributes::SwitchActions::Id,
                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "switch-type", Attributes::SwitchType::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "switch-actions", Attributes::SwitchActions::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterLevelControl(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::LevelControl;

    const char * clusterName = "LevelControl";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                 //
        make_unique<LevelControlMoveToLevel>(credsIssuerConfig),            //
        make_unique<LevelControlMove>(credsIssuerConfig),                   //
        make_unique<LevelControlStep>(credsIssuerConfig),                   //
        make_unique<LevelControlStop>(credsIssuerConfig),                   //
        make_unique<LevelControlMoveToLevelWithOnOff>(credsIssuerConfig),   //
        make_unique<LevelControlMoveWithOnOff>(credsIssuerConfig),          //
        make_unique<LevelControlStepWithOnOff>(credsIssuerConfig),          //
        make_unique<LevelControlStopWithOnOff>(credsIssuerConfig),          //
        make_unique<LevelControlMoveToClosestFrequency>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "current-level", Attributes::CurrentLevel::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "remaining-time", Attributes::RemainingTime::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "min-level", Attributes::MinLevel::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "max-level", Attributes::MaxLevel::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "current-frequency", Attributes::CurrentFrequency::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "min-frequency", Attributes::MinFrequency::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "max-frequency", Attributes::MaxFrequency::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "options", Attributes::Options::Id, credsIssuerConfig),                             //
        make_unique<ReadAttribute>(Id, "on-off-transition-time", Attributes::OnOffTransitionTime::Id, credsIssuerConfig),  //
        make_unique<ReadAttribute>(Id, "on-level", Attributes::OnLevel::Id, credsIssuerConfig),                            //
        make_unique<ReadAttribute>(Id, "on-transition-time", Attributes::OnTransitionTime::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "off-transition-time", Attributes::OffTransitionTime::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "default-move-rate", Attributes::DefaultMoveRate::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "start-up-current-level", Attributes::StartUpCurrentLevel::Id, credsIssuerConfig),  //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(
            Id, "current-level", 0, UINT8_MAX, Attributes::CurrentLevel::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "remaining-time", 0, UINT16_MAX, Attributes::RemainingTime::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "min-level", 0, UINT8_MAX, Attributes::MinLevel::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "max-level", 0, UINT8_MAX, Attributes::MaxLevel::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "current-frequency", 0, UINT16_MAX, Attributes::CurrentFrequency::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "min-frequency", 0, UINT16_MAX, Attributes::MinFrequency::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "max-frequency", 0, UINT16_MAX, Attributes::MaxFrequency::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::LevelControl::OptionsBitmap>>>(
            Id, "options", 0, UINT8_MAX, Attributes::Options::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "on-off-transition-time", 0, UINT16_MAX, Attributes::OnOffTransitionTime::Id,
                                              WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(Id, "on-level", 0, UINT8_MAX, Attributes::OnLevel::Id,
                                                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint16_t>>>(Id, "on-transition-time", 0, UINT16_MAX,
                                                                              Attributes::OnTransitionTime::Id,
                                                                              WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint16_t>>>(Id, "off-transition-time", 0, UINT16_MAX,
                                                                              Attributes::OffTransitionTime::Id,
                                                                              WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(
            Id, "default-move-rate", 0, UINT8_MAX, Attributes::DefaultMoveRate::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(Id, "start-up-current-level", 0, UINT8_MAX,
                                                                             Attributes::StartUpCurrentLevel::Id,
                                                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "current-level", Attributes::CurrentLevel::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "remaining-time", Attributes::RemainingTime::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "min-level", Attributes::MinLevel::Id, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, "max-level", Attributes::MaxLevel::Id, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, "current-frequency", Attributes::CurrentFrequency::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "min-frequency", Attributes::MinFrequency::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "max-frequency", Attributes::MaxFrequency::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "options", Attributes::Options::Id, credsIssuerConfig),                             //
        make_unique<SubscribeAttribute>(Id, "on-off-transition-time", Attributes::OnOffTransitionTime::Id, credsIssuerConfig),  //
        make_unique<SubscribeAttribute>(Id, "on-level", Attributes::OnLevel::Id, credsIssuerConfig),                            //
        make_unique<SubscribeAttribute>(Id, "on-transition-time", Attributes::OnTransitionTime::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "off-transition-time", Attributes::OffTransitionTime::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "default-move-rate", Attributes::DefaultMoveRate::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "start-up-current-level", Attributes::StartUpCurrentLevel::Id, credsIssuerConfig),  //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterBinaryInputBasic(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::BinaryInputBasic;

    const char * clusterName = "BinaryInputBasic";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "active-text", Attributes::ActiveText::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "description", Attributes::Description::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "inactive-text", Attributes::InactiveText::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "out-of-service", Attributes::OutOfService::Id, credsIssuerConfig),                 //
        make_unique<ReadAttribute>(Id, "polarity", Attributes::Polarity::Id, credsIssuerConfig),                           //
        make_unique<ReadAttribute>(Id, "present-value", Attributes::PresentValue::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "reliability", Attributes::Reliability::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "status-flags", Attributes::StatusFlags::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "application-type", Attributes::ApplicationType::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "active-text", Attributes::ActiveText::Id, WriteCommandType::kWrite,
                                                    credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "description", Attributes::Description::Id, WriteCommandType::kWrite,
                                                    credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "inactive-text", Attributes::InactiveText::Id, WriteCommandType::kWrite,
                                                    credsIssuerConfig), //
        make_unique<WriteAttribute<bool>>(Id, "out-of-service", 0, 1, Attributes::OutOfService::Id, WriteCommandType::kWrite,
                                          credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "polarity", 0, UINT8_MAX, Attributes::Polarity::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<bool>>(Id, "present-value", 0, 1, Attributes::PresentValue::Id, WriteCommandType::kWrite,
                                          credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "reliability", 0, UINT8_MAX, Attributes::Reliability::Id, WriteCommandType::kWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "status-flags", 0, UINT8_MAX, Attributes::StatusFlags::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "application-type", 0, UINT32_MAX, Attributes::ApplicationType::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "active-text", Attributes::ActiveText::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "description", Attributes::Description::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "inactive-text", Attributes::InactiveText::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "out-of-service", Attributes::OutOfService::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "polarity", Attributes::Polarity::Id, credsIssuerConfig),                           //
        make_unique<SubscribeAttribute>(Id, "present-value", Attributes::PresentValue::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "reliability", Attributes::Reliability::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "status-flags", Attributes::StatusFlags::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "application-type", Attributes::ApplicationType::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterPulseWidthModulation(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::PulseWidthModulation;

    const char * clusterName = "PulseWidthModulation";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterDescriptor(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::Descriptor;

    const char * clusterName = "Descriptor";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "device-type-list", Attributes::DeviceTypeList::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "server-list", Attributes::ServerList::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "client-list", Attributes::ClientList::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "parts-list", Attributes::PartsList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "tag-list", Attributes::TagList::Id, credsIssuerConfig),                            //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::Descriptor::Structs::DeviceTypeStruct::Type>>>(
            Id, "device-type-list", Attributes::DeviceTypeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::ClusterId>>>(
            Id, "server-list", Attributes::ServerList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::ClusterId>>>(
            Id, "client-list", Attributes::ClientList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EndpointId>>>(
            Id, "parts-list", Attributes::PartsList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::Descriptor::Structs::SemanticTagStruct::Type>>>(
            Id, "tag-list", Attributes::TagList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "device-type-list", Attributes::DeviceTypeList::Id, credsIssuerConfig),             //
        make_unique<SubscribeAttribute>(Id, "server-list", Attributes::ServerList::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "client-list", Attributes::ClientList::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "parts-list", Attributes::PartsList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "tag-list", Attributes::TagList::Id, credsIssuerConfig),                            //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterBinding(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::Binding;

    const char * clusterName = "Binding";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "binding", Attributes::Binding::Id, credsIssuerConfig),                             //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<
            WriteAttributeAsComplex<chip::app::DataModel::List<const chip::app::Clusters::Binding::Structs::TargetStruct::Type>>>(
            Id, "binding", Attributes::Binding::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "binding", Attributes::Binding::Id, credsIssuerConfig),                             //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterAccessControl(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::AccessControl;

    const char * clusterName = "AccessControl";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                         //
        make_unique<ReadAttribute>(Id, "acl", Attributes::Acl::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "extension", Attributes::Extension::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "subjects-per-access-control-entry", Attributes::SubjectsPerAccessControlEntry::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "targets-per-access-control-entry", Attributes::TargetsPerAccessControlEntry::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "access-control-entries-per-fabric", Attributes::AccessControlEntriesPerFabric::Id,
                                   credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::AccessControl::Structs::AccessControlEntryStruct::Type>>>(
            Id, "acl", Attributes::Acl::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::AccessControl::Structs::AccessControlExtensionStruct::Type>>>(
            Id, "extension", Attributes::Extension::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "subjects-per-access-control-entry", 0, UINT16_MAX,
                                              Attributes::SubjectsPerAccessControlEntry::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "targets-per-access-control-entry", 0, UINT16_MAX,
                                              Attributes::TargetsPerAccessControlEntry::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "access-control-entries-per-fabric", 0, UINT16_MAX,
                                              Attributes::AccessControlEntriesPerFabric::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                         //
        make_unique<SubscribeAttribute>(Id, "acl", Attributes::Acl::Id, credsIssuerConfig),             //
        make_unique<SubscribeAttribute>(Id, "extension", Attributes::Extension::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "subjects-per-access-control-entry", Attributes::SubjectsPerAccessControlEntry::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "targets-per-access-control-entry", Attributes::TargetsPerAccessControlEntry::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "access-control-entries-per-fabric", Attributes::AccessControlEntriesPerFabric::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                                        //
        make_unique<ReadEvent>(Id, "access-control-entry-changed", Events::AccessControlEntryChanged::Id, credsIssuerConfig), //
        make_unique<ReadEvent>(Id, "access-control-extension-changed", Events::AccessControlExtensionChanged::Id,
                               credsIssuerConfig),          //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
        make_unique<SubscribeEvent>(Id, "access-control-entry-changed", Events::AccessControlEntryChanged::Id,
                                    credsIssuerConfig), //
        make_unique<SubscribeEvent>(Id, "access-control-extension-changed", Events::AccessControlExtensionChanged::Id,
                                    credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterActions(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::Actions;

    const char * clusterName = "Actions";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                 //
        make_unique<ActionsInstantAction>(credsIssuerConfig),               //
        make_unique<ActionsInstantActionWithTransition>(credsIssuerConfig), //
        make_unique<ActionsStartAction>(credsIssuerConfig),                 //
        make_unique<ActionsStartActionWithDuration>(credsIssuerConfig),     //
        make_unique<ActionsStopAction>(credsIssuerConfig),                  //
        make_unique<ActionsPauseAction>(credsIssuerConfig),                 //
        make_unique<ActionsPauseActionWithDuration>(credsIssuerConfig),     //
        make_unique<ActionsResumeAction>(credsIssuerConfig),                //
        make_unique<ActionsEnableAction>(credsIssuerConfig),                //
        make_unique<ActionsEnableActionWithDuration>(credsIssuerConfig),    //
        make_unique<ActionsDisableAction>(credsIssuerConfig),               //
        make_unique<ActionsDisableActionWithDuration>(credsIssuerConfig),   //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "action-list", Attributes::ActionList::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "endpoint-lists", Attributes::EndpointLists::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "setup-url", Attributes::SetupURL::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<
            WriteAttributeAsComplex<chip::app::DataModel::List<const chip::app::Clusters::Actions::Structs::ActionStruct::Type>>>(
            Id, "action-list", Attributes::ActionList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::Actions::Structs::EndpointListStruct::Type>>>(
            Id, "endpoint-lists", Attributes::EndpointLists::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "setup-url", Attributes::SetupURL::Id, WriteCommandType::kForceWrite,
                                                    credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "action-list", Attributes::ActionList::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "endpoint-lists", Attributes::EndpointLists::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "setup-url", Attributes::SetupURL::Id, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                 //
        make_unique<ReadEvent>(Id, "state-changed", Events::StateChanged::Id, credsIssuerConfig),      //
        make_unique<ReadEvent>(Id, "action-failed", Events::ActionFailed::Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                            //
        make_unique<SubscribeEvent>(Id, "state-changed", Events::StateChanged::Id, credsIssuerConfig), //
        make_unique<SubscribeEvent>(Id, "action-failed", Events::ActionFailed::Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterBasicInformation(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::BasicInformation;

    const char * clusterName = "BasicInformation";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),              //
        make_unique<BasicInformationMfgSpecificPing>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                   //
        make_unique<ReadAttribute>(Id, "data-model-revision", Attributes::DataModelRevision::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "vendor-name", Attributes::VendorName::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "vendor-id", Attributes::VendorID::Id, credsIssuerConfig),                            //
        make_unique<ReadAttribute>(Id, "product-name", Attributes::ProductName::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "product-id", Attributes::ProductID::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "node-label", Attributes::NodeLabel::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "location", Attributes::Location::Id, credsIssuerConfig),                             //
        make_unique<ReadAttribute>(Id, "hardware-version", Attributes::HardwareVersion::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "hardware-version-string", Attributes::HardwareVersionString::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "software-version", Attributes::SoftwareVersion::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "software-version-string", Attributes::SoftwareVersionString::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "manufacturing-date", Attributes::ManufacturingDate::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "part-number", Attributes::PartNumber::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "product-url", Attributes::ProductURL::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "product-label", Attributes::ProductLabel::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "serial-number", Attributes::SerialNumber::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "local-config-disabled", Attributes::LocalConfigDisabled::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "reachable", Attributes::Reachable::Id, credsIssuerConfig),                           //
        make_unique<ReadAttribute>(Id, "unique-id", Attributes::UniqueID::Id, credsIssuerConfig),                            //
        make_unique<ReadAttribute>(Id, "capability-minima", Attributes::CapabilityMinima::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "product-appearance", Attributes::ProductAppearance::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "specification-version", Attributes::SpecificationVersion::Id, credsIssuerConfig),    //
        make_unique<ReadAttribute>(Id, "max-paths-per-invoke", Attributes::MaxPathsPerInvoke::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),              //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                                //
        make_unique<WriteAttribute<uint16_t>>(Id, "data-model-revision", 0, UINT16_MAX, Attributes::DataModelRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "vendor-name", Attributes::VendorName::Id, WriteCommandType::kForceWrite,
                                                    credsIssuerConfig), //
        make_unique<WriteAttribute<chip::VendorId>>(Id, "vendor-id", 0, UINT16_MAX, Attributes::VendorID::Id,
                                                    WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "product-name", Attributes::ProductName::Id, WriteCommandType::kForceWrite,
                                                    credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "product-id", 0, UINT16_MAX, Attributes::ProductID::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "node-label", Attributes::NodeLabel::Id, WriteCommandType::kWrite,
                                                    credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "location", Attributes::Location::Id, WriteCommandType::kWrite,
                                                    credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "hardware-version", 0, UINT16_MAX, Attributes::HardwareVersion::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "hardware-version-string", Attributes::HardwareVersionString::Id,
                                                    WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "software-version", 0, UINT32_MAX, Attributes::SoftwareVersion::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "software-version-string", Attributes::SoftwareVersionString::Id,
                                                    WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "manufacturing-date", Attributes::ManufacturingDate::Id,
                                                    WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "part-number", Attributes::PartNumber::Id, WriteCommandType::kForceWrite,
                                                    credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "product-url", Attributes::ProductURL::Id, WriteCommandType::kForceWrite,
                                                    credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "product-label", Attributes::ProductLabel::Id,
                                                    WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "serial-number", Attributes::SerialNumber::Id,
                                                    WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<bool>>(Id, "local-config-disabled", 0, 1, Attributes::LocalConfigDisabled::Id,
                                          WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<bool>>(Id, "reachable", 0, 1, Attributes::Reachable::Id, WriteCommandType::kForceWrite,
                                          credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "unique-id", Attributes::UniqueID::Id, WriteCommandType::kForceWrite,
                                                    credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::Clusters::BasicInformation::Structs::CapabilityMinimaStruct::Type>>(
            Id, "capability-minima", Attributes::CapabilityMinima::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::Clusters::BasicInformation::Structs::ProductAppearanceStruct::Type>>(
            Id, "product-appearance", Attributes::ProductAppearance::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "specification-version", 0, UINT32_MAX, Attributes::SpecificationVersion::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "max-paths-per-invoke", 0, UINT16_MAX, Attributes::MaxPathsPerInvoke::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                  //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                   //
        make_unique<SubscribeAttribute>(Id, "data-model-revision", Attributes::DataModelRevision::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "vendor-name", Attributes::VendorName::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "vendor-id", Attributes::VendorID::Id, credsIssuerConfig),                            //
        make_unique<SubscribeAttribute>(Id, "product-name", Attributes::ProductName::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "product-id", Attributes::ProductID::Id, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, "node-label", Attributes::NodeLabel::Id, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, "location", Attributes::Location::Id, credsIssuerConfig),                             //
        make_unique<SubscribeAttribute>(Id, "hardware-version", Attributes::HardwareVersion::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "hardware-version-string", Attributes::HardwareVersionString::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "software-version", Attributes::SoftwareVersion::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "software-version-string", Attributes::SoftwareVersionString::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "manufacturing-date", Attributes::ManufacturingDate::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "part-number", Attributes::PartNumber::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "product-url", Attributes::ProductURL::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "product-label", Attributes::ProductLabel::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "serial-number", Attributes::SerialNumber::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "local-config-disabled", Attributes::LocalConfigDisabled::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "reachable", Attributes::Reachable::Id, credsIssuerConfig),                           //
        make_unique<SubscribeAttribute>(Id, "unique-id", Attributes::UniqueID::Id, credsIssuerConfig),                            //
        make_unique<SubscribeAttribute>(Id, "capability-minima", Attributes::CapabilityMinima::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "product-appearance", Attributes::ProductAppearance::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "specification-version", Attributes::SpecificationVersion::Id, credsIssuerConfig),    //
        make_unique<SubscribeAttribute>(Id, "max-paths-per-invoke", Attributes::MaxPathsPerInvoke::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),              //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                         //
        make_unique<ReadEvent>(Id, "start-up", Events::StartUp::Id, credsIssuerConfig),                        //
        make_unique<ReadEvent>(Id, "shut-down", Events::ShutDown::Id, credsIssuerConfig),                      //
        make_unique<ReadEvent>(Id, "leave", Events::Leave::Id, credsIssuerConfig),                             //
        make_unique<ReadEvent>(Id, "reachable-changed", Events::ReachableChanged::Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                    //
        make_unique<SubscribeEvent>(Id, "start-up", Events::StartUp::Id, credsIssuerConfig),                   //
        make_unique<SubscribeEvent>(Id, "shut-down", Events::ShutDown::Id, credsIssuerConfig),                 //
        make_unique<SubscribeEvent>(Id, "leave", Events::Leave::Id, credsIssuerConfig),                        //
        make_unique<SubscribeEvent>(Id, "reachable-changed", Events::ReachableChanged::Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterOtaSoftwareUpdateProvider(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::OtaSoftwareUpdateProvider;

    const char * clusterName = "OtaSoftwareUpdateProvider";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                           //
        make_unique<OtaSoftwareUpdateProviderQueryImage>(credsIssuerConfig),          //
        make_unique<OtaSoftwareUpdateProviderApplyUpdateRequest>(credsIssuerConfig),  //
        make_unique<OtaSoftwareUpdateProviderNotifyUpdateApplied>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterOtaSoftwareUpdateRequestor(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::OtaSoftwareUpdateRequestor;

    const char * clusterName = "OtaSoftwareUpdateRequestor";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                            //
        make_unique<OtaSoftwareUpdateRequestorAnnounceOTAProvider>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "default-otaproviders", Attributes::DefaultOTAProviders::Id, credsIssuerConfig),    //
        make_unique<ReadAttribute>(Id, "update-possible", Attributes::UpdatePossible::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "update-state", Attributes::UpdateState::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "update-state-progress", Attributes::UpdateStateProgress::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::OtaSoftwareUpdateRequestor::Structs::ProviderLocation::Type>>>(
            Id, "default-otaproviders", Attributes::DefaultOTAProviders::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<bool>>(Id, "update-possible", 0, 1, Attributes::UpdatePossible::Id,
                                          WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::OtaSoftwareUpdateRequestor::UpdateStateEnum>>(
            Id, "update-state", 0, UINT8_MAX, Attributes::UpdateState::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(Id, "update-state-progress", 0, UINT8_MAX,
                                                                             Attributes::UpdateStateProgress::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "default-otaproviders", Attributes::DefaultOTAProviders::Id, credsIssuerConfig),    //
        make_unique<SubscribeAttribute>(Id, "update-possible", Attributes::UpdatePossible::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "update-state", Attributes::UpdateState::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "update-state-progress", Attributes::UpdateStateProgress::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                       //
        make_unique<ReadEvent>(Id, "state-transition", Events::StateTransition::Id, credsIssuerConfig),      //
        make_unique<ReadEvent>(Id, "version-applied", Events::VersionApplied::Id, credsIssuerConfig),        //
        make_unique<ReadEvent>(Id, "download-error", Events::DownloadError::Id, credsIssuerConfig),          //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                  //
        make_unique<SubscribeEvent>(Id, "state-transition", Events::StateTransition::Id, credsIssuerConfig), //
        make_unique<SubscribeEvent>(Id, "version-applied", Events::VersionApplied::Id, credsIssuerConfig),   //
        make_unique<SubscribeEvent>(Id, "download-error", Events::DownloadError::Id, credsIssuerConfig),     //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterLocalizationConfiguration(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::LocalizationConfiguration;

    const char * clusterName = "LocalizationConfiguration";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "active-locale", Attributes::ActiveLocale::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "supported-locales", Attributes::SupportedLocales::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "active-locale", Attributes::ActiveLocale::Id, WriteCommandType::kWrite,
                                                    credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CharSpan>>>(
            Id, "supported-locales", Attributes::SupportedLocales::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "active-locale", Attributes::ActiveLocale::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "supported-locales", Attributes::SupportedLocales::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterTimeFormatLocalization(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::TimeFormatLocalization;

    const char * clusterName = "TimeFormatLocalization";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "hour-format", Attributes::HourFormat::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "active-calendar-type", Attributes::ActiveCalendarType::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "supported-calendar-types", Attributes::SupportedCalendarTypes::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                            //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),                //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                                  //
        make_unique<WriteAttribute<chip::app::Clusters::TimeFormatLocalization::HourFormatEnum>>(
            Id, "hour-format", 0, UINT8_MAX, Attributes::HourFormat::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::TimeFormatLocalization::CalendarTypeEnum>>(
            Id, "active-calendar-type", 0, UINT8_MAX, Attributes::ActiveCalendarType::Id, WriteCommandType::kWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::TimeFormatLocalization::CalendarTypeEnum>>>(
            Id, "supported-calendar-types", Attributes::SupportedCalendarTypes::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                            //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                             //
        make_unique<SubscribeAttribute>(Id, "hour-format", Attributes::HourFormat::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "active-calendar-type", Attributes::ActiveCalendarType::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "supported-calendar-types", Attributes::SupportedCalendarTypes::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterUnitLocalization(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::UnitLocalization;

    const char * clusterName = "UnitLocalization";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "temperature-unit", Attributes::TemperatureUnit::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::app::Clusters::UnitLocalization::TempUnitEnum>>(
            Id, "temperature-unit", 0, UINT8_MAX, Attributes::TemperatureUnit::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "temperature-unit", Attributes::TemperatureUnit::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterPowerSourceConfiguration(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::PowerSourceConfiguration;

    const char * clusterName = "PowerSourceConfiguration";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "sources", Attributes::Sources::Id, credsIssuerConfig),                             //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EndpointId>>>(
            Id, "sources", Attributes::Sources::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "sources", Attributes::Sources::Id, credsIssuerConfig),                             //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterPowerSource(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::PowerSource;

    const char * clusterName = "PowerSource";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                             //
        make_unique<ReadAttribute>(Id, "status", Attributes::Status::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "order", Attributes::Order::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "description", Attributes::Description::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "wired-assessed-input-voltage", Attributes::WiredAssessedInputVoltage::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "wired-assessed-input-frequency", Attributes::WiredAssessedInputFrequency::Id,
                                   credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "wired-current-type", Attributes::WiredCurrentType::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "wired-assessed-current", Attributes::WiredAssessedCurrent::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "wired-nominal-voltage", Attributes::WiredNominalVoltage::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "wired-maximum-current", Attributes::WiredMaximumCurrent::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "wired-present", Attributes::WiredPresent::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "active-wired-faults", Attributes::ActiveWiredFaults::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "bat-voltage", Attributes::BatVoltage::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "bat-percent-remaining", Attributes::BatPercentRemaining::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "bat-time-remaining", Attributes::BatTimeRemaining::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "bat-charge-level", Attributes::BatChargeLevel::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "bat-replacement-needed", Attributes::BatReplacementNeeded::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "bat-replaceability", Attributes::BatReplaceability::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "bat-present", Attributes::BatPresent::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "active-bat-faults", Attributes::ActiveBatFaults::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "bat-replacement-description", Attributes::BatReplacementDescription::Id,
                                   credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "bat-common-designation", Attributes::BatCommonDesignation::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "bat-ansidesignation", Attributes::BatANSIDesignation::Id, credsIssuerConfig),      //
        make_unique<ReadAttribute>(Id, "bat-iecdesignation", Attributes::BatIECDesignation::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "bat-approved-chemistry", Attributes::BatApprovedChemistry::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "bat-capacity", Attributes::BatCapacity::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "bat-quantity", Attributes::BatQuantity::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "bat-charge-state", Attributes::BatChargeState::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "bat-time-to-full-charge", Attributes::BatTimeToFullCharge::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "bat-functional-while-charging", Attributes::BatFunctionalWhileCharging::Id,
                                   credsIssuerConfig),                                                                        //
        make_unique<ReadAttribute>(Id, "bat-charging-current", Attributes::BatChargingCurrent::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "active-bat-charge-faults", Attributes::ActiveBatChargeFaults::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "endpoint-list", Attributes::EndpointList::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig),    //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),      //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                           //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),               //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                                 //
        make_unique<WriteAttribute<chip::app::Clusters::PowerSource::PowerSourceStatusEnum>>(
            Id, "status", 0, UINT8_MAX, Attributes::Status::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "order", 0, UINT8_MAX, Attributes::Order::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "description", Attributes::Description::Id, WriteCommandType::kForceWrite,
                                                    credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(Id, "wired-assessed-input-voltage", 0, UINT32_MAX,
                                                                              Attributes::WiredAssessedInputVoltage::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint16_t>>>(Id, "wired-assessed-input-frequency", 0, UINT16_MAX,
                                                                              Attributes::WiredAssessedInputFrequency::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::PowerSource::WiredCurrentTypeEnum>>(
            Id, "wired-current-type", 0, UINT8_MAX, Attributes::WiredCurrentType::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(Id, "wired-assessed-current", 0, UINT32_MAX,
                                                                              Attributes::WiredAssessedCurrent::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "wired-nominal-voltage", 0, UINT32_MAX, Attributes::WiredNominalVoltage::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "wired-maximum-current", 0, UINT32_MAX, Attributes::WiredMaximumCurrent::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<bool>>(Id, "wired-present", 0, 1, Attributes::WiredPresent::Id, WriteCommandType::kForceWrite,
                                          credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::app::Clusters::PowerSource::WiredFaultEnum>>>(
            Id, "active-wired-faults", Attributes::ActiveWiredFaults::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(
            Id, "bat-voltage", 0, UINT32_MAX, Attributes::BatVoltage::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(Id, "bat-percent-remaining", 0, UINT8_MAX,
                                                                             Attributes::BatPercentRemaining::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(Id, "bat-time-remaining", 0, UINT32_MAX,
                                                                              Attributes::BatTimeRemaining::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::PowerSource::BatChargeLevelEnum>>(
            Id, "bat-charge-level", 0, UINT8_MAX, Attributes::BatChargeLevel::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<bool>>(Id, "bat-replacement-needed", 0, 1, Attributes::BatReplacementNeeded::Id,
                                          WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::PowerSource::BatReplaceabilityEnum>>(
            Id, "bat-replaceability", 0, UINT8_MAX, Attributes::BatReplaceability::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<bool>>(Id, "bat-present", 0, 1, Attributes::BatPresent::Id, WriteCommandType::kForceWrite,
                                          credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::app::Clusters::PowerSource::BatFaultEnum>>>(
            Id, "active-bat-faults", Attributes::ActiveBatFaults::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "bat-replacement-description", Attributes::BatReplacementDescription::Id,
                                                    WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::PowerSource::BatCommonDesignationEnum>>(
            Id, "bat-common-designation", 0, UINT16_MAX, Attributes::BatCommonDesignation::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "bat-ansidesignation", Attributes::BatANSIDesignation::Id,
                                                    WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "bat-iecdesignation", Attributes::BatIECDesignation::Id,
                                                    WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::PowerSource::BatApprovedChemistryEnum>>(
            Id, "bat-approved-chemistry", 0, UINT16_MAX, Attributes::BatApprovedChemistry::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "bat-capacity", 0, UINT32_MAX, Attributes::BatCapacity::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "bat-quantity", 0, UINT8_MAX, Attributes::BatQuantity::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::PowerSource::BatChargeStateEnum>>(
            Id, "bat-charge-state", 0, UINT8_MAX, Attributes::BatChargeState::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(Id, "bat-time-to-full-charge", 0, UINT32_MAX,
                                                                              Attributes::BatTimeToFullCharge::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<bool>>(Id, "bat-functional-while-charging", 0, 1, Attributes::BatFunctionalWhileCharging::Id,
                                          WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(Id, "bat-charging-current", 0, UINT32_MAX,
                                                                              Attributes::BatChargingCurrent::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<
            WriteAttributeAsComplex<chip::app::DataModel::List<const chip::app::Clusters::PowerSource::BatChargeFaultEnum>>>(
            Id, "active-bat-charge-faults", Attributes::ActiveBatChargeFaults::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EndpointId>>>(
            Id, "endpoint-list", Attributes::EndpointList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                             //
        make_unique<SubscribeAttribute>(Id, "status", Attributes::Status::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "order", Attributes::Order::Id, credsIssuerConfig),             //
        make_unique<SubscribeAttribute>(Id, "description", Attributes::Description::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "wired-assessed-input-voltage", Attributes::WiredAssessedInputVoltage::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "wired-assessed-input-frequency", Attributes::WiredAssessedInputFrequency::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "wired-current-type", Attributes::WiredCurrentType::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "wired-assessed-current", Attributes::WiredAssessedCurrent::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "wired-nominal-voltage", Attributes::WiredNominalVoltage::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "wired-maximum-current", Attributes::WiredMaximumCurrent::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "wired-present", Attributes::WiredPresent::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "active-wired-faults", Attributes::ActiveWiredFaults::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "bat-voltage", Attributes::BatVoltage::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "bat-percent-remaining", Attributes::BatPercentRemaining::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "bat-time-remaining", Attributes::BatTimeRemaining::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "bat-charge-level", Attributes::BatChargeLevel::Id, credsIssuerConfig),             //
        make_unique<SubscribeAttribute>(Id, "bat-replacement-needed", Attributes::BatReplacementNeeded::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "bat-replaceability", Attributes::BatReplaceability::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "bat-present", Attributes::BatPresent::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "active-bat-faults", Attributes::ActiveBatFaults::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "bat-replacement-description", Attributes::BatReplacementDescription::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "bat-common-designation", Attributes::BatCommonDesignation::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "bat-ansidesignation", Attributes::BatANSIDesignation::Id, credsIssuerConfig),      //
        make_unique<SubscribeAttribute>(Id, "bat-iecdesignation", Attributes::BatIECDesignation::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "bat-approved-chemistry", Attributes::BatApprovedChemistry::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "bat-capacity", Attributes::BatCapacity::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "bat-quantity", Attributes::BatQuantity::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "bat-charge-state", Attributes::BatChargeState::Id, credsIssuerConfig),             //
        make_unique<SubscribeAttribute>(Id, "bat-time-to-full-charge", Attributes::BatTimeToFullCharge::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "bat-functional-while-charging", Attributes::BatFunctionalWhileCharging::Id,
                                        credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "bat-charging-current", Attributes::BatChargingCurrent::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "active-bat-charge-faults", Attributes::ActiveBatChargeFaults::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "endpoint-list", Attributes::EndpointList::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                                   //
        make_unique<ReadEvent>(Id, "wired-fault-change", Events::WiredFaultChange::Id, credsIssuerConfig),               //
        make_unique<ReadEvent>(Id, "bat-fault-change", Events::BatFaultChange::Id, credsIssuerConfig),                   //
        make_unique<ReadEvent>(Id, "bat-charge-fault-change", Events::BatChargeFaultChange::Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                              //
        make_unique<SubscribeEvent>(Id, "wired-fault-change", Events::WiredFaultChange::Id, credsIssuerConfig),          //
        make_unique<SubscribeEvent>(Id, "bat-fault-change", Events::BatFaultChange::Id, credsIssuerConfig),              //
        make_unique<SubscribeEvent>(Id, "bat-charge-fault-change", Events::BatChargeFaultChange::Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterGeneralCommissioning(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::GeneralCommissioning;

    const char * clusterName = "GeneralCommissioning";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                        //
        make_unique<GeneralCommissioningArmFailSafe>(credsIssuerConfig),           //
        make_unique<GeneralCommissioningSetRegulatoryConfig>(credsIssuerConfig),   //
        make_unique<GeneralCommissioningCommissioningComplete>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "breadcrumb", Attributes::Breadcrumb::Id, credsIssuerConfig),                           //
        make_unique<ReadAttribute>(Id, "basic-commissioning-info", Attributes::BasicCommissioningInfo::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "regulatory-config", Attributes::RegulatoryConfig::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "location-capability", Attributes::LocationCapability::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "supports-concurrent-connection", Attributes::SupportsConcurrentConnection::Id,
                                   credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<uint64_t>>(Id, "breadcrumb", 0, UINT64_MAX, Attributes::Breadcrumb::Id, WriteCommandType::kWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::Clusters::GeneralCommissioning::Structs::BasicCommissioningInfo::Type>>(
            Id, "basic-commissioning-info", Attributes::BasicCommissioningInfo::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::GeneralCommissioning::RegulatoryLocationTypeEnum>>(
            Id, "regulatory-config", 0, UINT8_MAX, Attributes::RegulatoryConfig::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::GeneralCommissioning::RegulatoryLocationTypeEnum>>(
            Id, "location-capability", 0, UINT8_MAX, Attributes::LocationCapability::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<bool>>(Id, "supports-concurrent-connection", 0, 1, Attributes::SupportsConcurrentConnection::Id,
                                          WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                           //
        make_unique<SubscribeAttribute>(Id, "breadcrumb", Attributes::Breadcrumb::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "basic-commissioning-info", Attributes::BasicCommissioningInfo::Id,
                                        credsIssuerConfig),                                                                //
        make_unique<SubscribeAttribute>(Id, "regulatory-config", Attributes::RegulatoryConfig::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "location-capability", Attributes::LocationCapability::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "supports-concurrent-connection", Attributes::SupportsConcurrentConnection::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterNetworkCommissioning(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::NetworkCommissioning;

    const char * clusterName = "NetworkCommissioning";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                           //
        make_unique<NetworkCommissioningScanNetworks>(credsIssuerConfig),             //
        make_unique<NetworkCommissioningAddOrUpdateWiFiNetwork>(credsIssuerConfig),   //
        make_unique<NetworkCommissioningAddOrUpdateThreadNetwork>(credsIssuerConfig), //
        make_unique<NetworkCommissioningRemoveNetwork>(credsIssuerConfig),            //
        make_unique<NetworkCommissioningConnectNetwork>(credsIssuerConfig),           //
        make_unique<NetworkCommissioningReorderNetwork>(credsIssuerConfig),           //
        make_unique<NetworkCommissioningQueryIdentity>(credsIssuerConfig),            //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                       //
        make_unique<ReadAttribute>(Id, "max-networks", Attributes::MaxNetworks::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "networks", Attributes::Networks::Id, credsIssuerConfig),                                 //
        make_unique<ReadAttribute>(Id, "scan-max-time-seconds", Attributes::ScanMaxTimeSeconds::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "connect-max-time-seconds", Attributes::ConnectMaxTimeSeconds::Id, credsIssuerConfig),    //
        make_unique<ReadAttribute>(Id, "interface-enabled", Attributes::InterfaceEnabled::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "last-networking-status", Attributes::LastNetworkingStatus::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "last-network-id", Attributes::LastNetworkID::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "last-connect-error-value", Attributes::LastConnectErrorValue::Id, credsIssuerConfig),    //
        make_unique<ReadAttribute>(Id, "supported-wi-fi-bands", Attributes::SupportedWiFiBands::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "supported-thread-features", Attributes::SupportedThreadFeatures::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "thread-version", Attributes::ThreadVersion::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                              //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                            //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),                  //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                                    //
        make_unique<WriteAttribute<uint8_t>>(Id, "max-networks", 0, UINT8_MAX, Attributes::MaxNetworks::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::NetworkCommissioning::Structs::NetworkInfoStruct::Type>>>(
            Id, "networks", Attributes::Networks::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "scan-max-time-seconds", 0, UINT8_MAX, Attributes::ScanMaxTimeSeconds::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "connect-max-time-seconds", 0, UINT8_MAX, Attributes::ConnectMaxTimeSeconds::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<bool>>(Id, "interface-enabled", 0, 1, Attributes::InterfaceEnabled::Id, WriteCommandType::kWrite,
                                          credsIssuerConfig), //
        make_unique<WriteAttribute<
            chip::app::DataModel::Nullable<chip::app::Clusters::NetworkCommissioning::NetworkCommissioningStatusEnum>>>(
            Id, "last-networking-status", 0, UINT8_MAX, Attributes::LastNetworkingStatus::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::ByteSpan>>>(
            Id, "last-network-id", Attributes::LastNetworkID::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int32_t>>>(Id, "last-connect-error-value", INT32_MIN, INT32_MAX,
                                                                             Attributes::LastConnectErrorValue::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<
            WriteAttributeAsComplex<chip::app::DataModel::List<const chip::app::Clusters::NetworkCommissioning::WiFiBandEnum>>>(
            Id, "supported-wi-fi-bands", Attributes::SupportedWiFiBands::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::NetworkCommissioning::ThreadCapabilitiesBitmap>>>(
            Id, "supported-thread-features", 0, UINT16_MAX, Attributes::SupportedThreadFeatures::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "thread-version", 0, UINT16_MAX, Attributes::ThreadVersion::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                             //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                              //
        make_unique<SubscribeAttribute>(Id, "max-networks", Attributes::MaxNetworks::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "networks", Attributes::Networks::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "scan-max-time-seconds", Attributes::ScanMaxTimeSeconds::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "connect-max-time-seconds", Attributes::ConnectMaxTimeSeconds::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "interface-enabled", Attributes::InterfaceEnabled::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "last-networking-status", Attributes::LastNetworkingStatus::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "last-network-id", Attributes::LastNetworkID::Id, credsIssuerConfig),               //
        make_unique<SubscribeAttribute>(Id, "last-connect-error-value", Attributes::LastConnectErrorValue::Id,
                                        credsIssuerConfig),                                                                  //
        make_unique<SubscribeAttribute>(Id, "supported-wi-fi-bands", Attributes::SupportedWiFiBands::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "supported-thread-features", Attributes::SupportedThreadFeatures::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "thread-version", Attributes::ThreadVersion::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterDiagnosticLogs(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::DiagnosticLogs;

    const char * clusterName = "DiagnosticLogs";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                //
        make_unique<DiagnosticLogsRetrieveLogsRequest>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterGeneralDiagnostics(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::GeneralDiagnostics;

    const char * clusterName = "GeneralDiagnostics";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                   //
        make_unique<GeneralDiagnosticsTestEventTrigger>(credsIssuerConfig),   //
        make_unique<GeneralDiagnosticsTimeSnapshot>(credsIssuerConfig),       //
        make_unique<GeneralDiagnosticsPayloadTestRequest>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                   //
        make_unique<ReadAttribute>(Id, "network-interfaces", Attributes::NetworkInterfaces::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "reboot-count", Attributes::RebootCount::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "up-time", Attributes::UpTime::Id, credsIssuerConfig),                                //
        make_unique<ReadAttribute>(Id, "total-operational-hours", Attributes::TotalOperationalHours::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "boot-reason", Attributes::BootReason::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "active-hardware-faults", Attributes::ActiveHardwareFaults::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "active-radio-faults", Attributes::ActiveRadioFaults::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "active-network-faults", Attributes::ActiveNetworkFaults::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "test-event-triggers-enabled", Attributes::TestEventTriggersEnabled::Id,
                                   credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::GeneralDiagnostics::Structs::NetworkInterface::Type>>>(
            Id, "network-interfaces", Attributes::NetworkInterfaces::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "reboot-count", 0, UINT16_MAX, Attributes::RebootCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint64_t>>(Id, "up-time", 0, UINT64_MAX, Attributes::UpTime::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "total-operational-hours", 0, UINT32_MAX, Attributes::TotalOperationalHours::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::GeneralDiagnostics::BootReasonEnum>>(
            Id, "boot-reason", 0, UINT8_MAX, Attributes::BootReason::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<
            WriteAttributeAsComplex<chip::app::DataModel::List<const chip::app::Clusters::GeneralDiagnostics::HardwareFaultEnum>>>(
            Id, "active-hardware-faults", Attributes::ActiveHardwareFaults::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<
            WriteAttributeAsComplex<chip::app::DataModel::List<const chip::app::Clusters::GeneralDiagnostics::RadioFaultEnum>>>(
            Id, "active-radio-faults", Attributes::ActiveRadioFaults::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<
            WriteAttributeAsComplex<chip::app::DataModel::List<const chip::app::Clusters::GeneralDiagnostics::NetworkFaultEnum>>>(
            Id, "active-network-faults", Attributes::ActiveNetworkFaults::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<bool>>(Id, "test-event-triggers-enabled", 0, 1, Attributes::TestEventTriggersEnabled::Id,
                                          WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                  //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                   //
        make_unique<SubscribeAttribute>(Id, "network-interfaces", Attributes::NetworkInterfaces::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "reboot-count", Attributes::RebootCount::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "up-time", Attributes::UpTime::Id, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, "total-operational-hours", Attributes::TotalOperationalHours::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "boot-reason", Attributes::BootReason::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "active-hardware-faults", Attributes::ActiveHardwareFaults::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "active-radio-faults", Attributes::ActiveRadioFaults::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "active-network-faults", Attributes::ActiveNetworkFaults::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "test-event-triggers-enabled", Attributes::TestEventTriggersEnabled::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                                //
        make_unique<ReadEvent>(Id, "hardware-fault-change", Events::HardwareFaultChange::Id, credsIssuerConfig),      //
        make_unique<ReadEvent>(Id, "radio-fault-change", Events::RadioFaultChange::Id, credsIssuerConfig),            //
        make_unique<ReadEvent>(Id, "network-fault-change", Events::NetworkFaultChange::Id, credsIssuerConfig),        //
        make_unique<ReadEvent>(Id, "boot-reason", Events::BootReason::Id, credsIssuerConfig),                         //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                           //
        make_unique<SubscribeEvent>(Id, "hardware-fault-change", Events::HardwareFaultChange::Id, credsIssuerConfig), //
        make_unique<SubscribeEvent>(Id, "radio-fault-change", Events::RadioFaultChange::Id, credsIssuerConfig),       //
        make_unique<SubscribeEvent>(Id, "network-fault-change", Events::NetworkFaultChange::Id, credsIssuerConfig),   //
        make_unique<SubscribeEvent>(Id, "boot-reason", Events::BootReason::Id, credsIssuerConfig),                    //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterSoftwareDiagnostics(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::SoftwareDiagnostics;

    const char * clusterName = "SoftwareDiagnostics";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                 //
        make_unique<SoftwareDiagnosticsResetWatermarks>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                       //
        make_unique<ReadAttribute>(Id, "thread-metrics", Attributes::ThreadMetrics::Id, credsIssuerConfig),      //
        make_unique<ReadAttribute>(Id, "current-heap-free", Attributes::CurrentHeapFree::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "current-heap-used", Attributes::CurrentHeapUsed::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "current-heap-high-watermark", Attributes::CurrentHeapHighWatermark::Id,
                                   credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::SoftwareDiagnostics::Structs::ThreadMetricsStruct::Type>>>(
            Id, "thread-metrics", Attributes::ThreadMetrics::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint64_t>>(Id, "current-heap-free", 0, UINT64_MAX, Attributes::CurrentHeapFree::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint64_t>>(Id, "current-heap-used", 0, UINT64_MAX, Attributes::CurrentHeapUsed::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint64_t>>(Id, "current-heap-high-watermark", 0, UINT64_MAX,
                                              Attributes::CurrentHeapHighWatermark::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                       //
        make_unique<SubscribeAttribute>(Id, "thread-metrics", Attributes::ThreadMetrics::Id, credsIssuerConfig),      //
        make_unique<SubscribeAttribute>(Id, "current-heap-free", Attributes::CurrentHeapFree::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "current-heap-used", Attributes::CurrentHeapUsed::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "current-heap-high-watermark", Attributes::CurrentHeapHighWatermark::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                   //
        make_unique<ReadEvent>(Id, "software-fault", Events::SoftwareFault::Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                              //
        make_unique<SubscribeEvent>(Id, "software-fault", Events::SoftwareFault::Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterThreadNetworkDiagnostics(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::ThreadNetworkDiagnostics;

    const char * clusterName = "ThreadNetworkDiagnostics";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                  //
        make_unique<ThreadNetworkDiagnosticsResetCounts>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                      //
        make_unique<ReadAttribute>(Id, "channel", Attributes::Channel::Id, credsIssuerConfig),                                  //
        make_unique<ReadAttribute>(Id, "routing-role", Attributes::RoutingRole::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "network-name", Attributes::NetworkName::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "pan-id", Attributes::PanId::Id, credsIssuerConfig),                                     //
        make_unique<ReadAttribute>(Id, "extended-pan-id", Attributes::ExtendedPanId::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "mesh-local-prefix", Attributes::MeshLocalPrefix::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "overrun-count", Attributes::OverrunCount::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "neighbor-table", Attributes::NeighborTable::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "route-table", Attributes::RouteTable::Id, credsIssuerConfig),                           //
        make_unique<ReadAttribute>(Id, "partition-id", Attributes::PartitionId::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "weighting", Attributes::Weighting::Id, credsIssuerConfig),                              //
        make_unique<ReadAttribute>(Id, "data-version", Attributes::DataVersion::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "stable-data-version", Attributes::StableDataVersion::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "leader-router-id", Attributes::LeaderRouterId::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "detached-role-count", Attributes::DetachedRoleCount::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "child-role-count", Attributes::ChildRoleCount::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "router-role-count", Attributes::RouterRoleCount::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "leader-role-count", Attributes::LeaderRoleCount::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "attach-attempt-count", Attributes::AttachAttemptCount::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "partition-id-change-count", Attributes::PartitionIdChangeCount::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "better-partition-attach-attempt-count", Attributes::BetterPartitionAttachAttemptCount::Id,
                                   credsIssuerConfig),                                                                         //
        make_unique<ReadAttribute>(Id, "parent-change-count", Attributes::ParentChangeCount::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "tx-total-count", Attributes::TxTotalCount::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "tx-unicast-count", Attributes::TxUnicastCount::Id, credsIssuerConfig),                 //
        make_unique<ReadAttribute>(Id, "tx-broadcast-count", Attributes::TxBroadcastCount::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "tx-ack-requested-count", Attributes::TxAckRequestedCount::Id, credsIssuerConfig),      //
        make_unique<ReadAttribute>(Id, "tx-acked-count", Attributes::TxAckedCount::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "tx-no-ack-requested-count", Attributes::TxNoAckRequestedCount::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "tx-data-count", Attributes::TxDataCount::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "tx-data-poll-count", Attributes::TxDataPollCount::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "tx-beacon-count", Attributes::TxBeaconCount::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "tx-beacon-request-count", Attributes::TxBeaconRequestCount::Id, credsIssuerConfig),    //
        make_unique<ReadAttribute>(Id, "tx-other-count", Attributes::TxOtherCount::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "tx-retry-count", Attributes::TxRetryCount::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "tx-direct-max-retry-expiry-count", Attributes::TxDirectMaxRetryExpiryCount::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "tx-indirect-max-retry-expiry-count", Attributes::TxIndirectMaxRetryExpiryCount::Id,
                                   credsIssuerConfig),                                                                          //
        make_unique<ReadAttribute>(Id, "tx-err-cca-count", Attributes::TxErrCcaCount::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "tx-err-abort-count", Attributes::TxErrAbortCount::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "tx-err-busy-channel-count", Attributes::TxErrBusyChannelCount::Id, credsIssuerConfig),  //
        make_unique<ReadAttribute>(Id, "rx-total-count", Attributes::RxTotalCount::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "rx-unicast-count", Attributes::RxUnicastCount::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "rx-broadcast-count", Attributes::RxBroadcastCount::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "rx-data-count", Attributes::RxDataCount::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "rx-data-poll-count", Attributes::RxDataPollCount::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "rx-beacon-count", Attributes::RxBeaconCount::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "rx-beacon-request-count", Attributes::RxBeaconRequestCount::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "rx-other-count", Attributes::RxOtherCount::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "rx-address-filtered-count", Attributes::RxAddressFilteredCount::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "rx-dest-addr-filtered-count", Attributes::RxDestAddrFilteredCount::Id,
                                   credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "rx-duplicated-count", Attributes::RxDuplicatedCount::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "rx-err-no-frame-count", Attributes::RxErrNoFrameCount::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "rx-err-unknown-neighbor-count", Attributes::RxErrUnknownNeighborCount::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "rx-err-invalid-src-addr-count", Attributes::RxErrInvalidSrcAddrCount::Id,
                                   credsIssuerConfig),                                                            //
        make_unique<ReadAttribute>(Id, "rx-err-sec-count", Attributes::RxErrSecCount::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "rx-err-fcs-count", Attributes::RxErrFcsCount::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "rx-err-other-count", Attributes::RxErrOtherCount::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "active-timestamp", Attributes::ActiveTimestamp::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "pending-timestamp", Attributes::PendingTimestamp::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "delay", Attributes::Delay::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "security-policy", Attributes::SecurityPolicy::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "channel-page0mask", Attributes::ChannelPage0Mask::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "operational-dataset-components", Attributes::OperationalDatasetComponents::Id,
                                   credsIssuerConfig),                                                                            //
        make_unique<ReadAttribute>(Id, "active-network-faults-list", Attributes::ActiveNetworkFaultsList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                               //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                             //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),                   //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                                     //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint16_t>>>(Id, "channel", 0, UINT16_MAX, Attributes::Channel::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::app::Clusters::ThreadNetworkDiagnostics::RoutingRoleEnum>>>(
            Id, "routing-role", 0, UINT8_MAX, Attributes::RoutingRole::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::CharSpan>>>(
            Id, "network-name", Attributes::NetworkName::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint16_t>>>(Id, "pan-id", 0, UINT16_MAX, Attributes::PanId::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint64_t>>>(Id, "extended-pan-id", 0, UINT64_MAX,
                                                                              Attributes::ExtendedPanId::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::ByteSpan>>>(
            Id, "mesh-local-prefix", Attributes::MeshLocalPrefix::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint64_t>>(Id, "overrun-count", 0, UINT64_MAX, Attributes::OverrunCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::ThreadNetworkDiagnostics::Structs::NeighborTableStruct::Type>>>(
            Id, "neighbor-table", Attributes::NeighborTable::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::ThreadNetworkDiagnostics::Structs::RouteTableStruct::Type>>>(
            Id, "route-table", Attributes::RouteTable::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(
            Id, "partition-id", 0, UINT32_MAX, Attributes::PartitionId::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint16_t>>>(
            Id, "weighting", 0, UINT16_MAX, Attributes::Weighting::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint16_t>>>(
            Id, "data-version", 0, UINT16_MAX, Attributes::DataVersion::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint16_t>>>(Id, "stable-data-version", 0, UINT16_MAX,
                                                                              Attributes::StableDataVersion::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(Id, "leader-router-id", 0, UINT8_MAX,
                                                                             Attributes::LeaderRouterId::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "detached-role-count", 0, UINT16_MAX, Attributes::DetachedRoleCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "child-role-count", 0, UINT16_MAX, Attributes::ChildRoleCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "router-role-count", 0, UINT16_MAX, Attributes::RouterRoleCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "leader-role-count", 0, UINT16_MAX, Attributes::LeaderRoleCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "attach-attempt-count", 0, UINT16_MAX, Attributes::AttachAttemptCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "partition-id-change-count", 0, UINT16_MAX,
                                              Attributes::PartitionIdChangeCount::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "better-partition-attach-attempt-count", 0, UINT16_MAX,
                                              Attributes::BetterPartitionAttachAttemptCount::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "parent-change-count", 0, UINT16_MAX, Attributes::ParentChangeCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "tx-total-count", 0, UINT32_MAX, Attributes::TxTotalCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "tx-unicast-count", 0, UINT32_MAX, Attributes::TxUnicastCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "tx-broadcast-count", 0, UINT32_MAX, Attributes::TxBroadcastCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "tx-ack-requested-count", 0, UINT32_MAX, Attributes::TxAckRequestedCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "tx-acked-count", 0, UINT32_MAX, Attributes::TxAckedCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "tx-no-ack-requested-count", 0, UINT32_MAX, Attributes::TxNoAckRequestedCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "tx-data-count", 0, UINT32_MAX, Attributes::TxDataCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "tx-data-poll-count", 0, UINT32_MAX, Attributes::TxDataPollCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "tx-beacon-count", 0, UINT32_MAX, Attributes::TxBeaconCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "tx-beacon-request-count", 0, UINT32_MAX, Attributes::TxBeaconRequestCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "tx-other-count", 0, UINT32_MAX, Attributes::TxOtherCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "tx-retry-count", 0, UINT32_MAX, Attributes::TxRetryCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "tx-direct-max-retry-expiry-count", 0, UINT32_MAX,
                                              Attributes::TxDirectMaxRetryExpiryCount::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "tx-indirect-max-retry-expiry-count", 0, UINT32_MAX,
                                              Attributes::TxIndirectMaxRetryExpiryCount::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "tx-err-cca-count", 0, UINT32_MAX, Attributes::TxErrCcaCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "tx-err-abort-count", 0, UINT32_MAX, Attributes::TxErrAbortCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "tx-err-busy-channel-count", 0, UINT32_MAX, Attributes::TxErrBusyChannelCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "rx-total-count", 0, UINT32_MAX, Attributes::RxTotalCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "rx-unicast-count", 0, UINT32_MAX, Attributes::RxUnicastCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "rx-broadcast-count", 0, UINT32_MAX, Attributes::RxBroadcastCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "rx-data-count", 0, UINT32_MAX, Attributes::RxDataCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "rx-data-poll-count", 0, UINT32_MAX, Attributes::RxDataPollCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "rx-beacon-count", 0, UINT32_MAX, Attributes::RxBeaconCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "rx-beacon-request-count", 0, UINT32_MAX, Attributes::RxBeaconRequestCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "rx-other-count", 0, UINT32_MAX, Attributes::RxOtherCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "rx-address-filtered-count", 0, UINT32_MAX,
                                              Attributes::RxAddressFilteredCount::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "rx-dest-addr-filtered-count", 0, UINT32_MAX,
                                              Attributes::RxDestAddrFilteredCount::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "rx-duplicated-count", 0, UINT32_MAX, Attributes::RxDuplicatedCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "rx-err-no-frame-count", 0, UINT32_MAX, Attributes::RxErrNoFrameCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "rx-err-unknown-neighbor-count", 0, UINT32_MAX,
                                              Attributes::RxErrUnknownNeighborCount::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "rx-err-invalid-src-addr-count", 0, UINT32_MAX,
                                              Attributes::RxErrInvalidSrcAddrCount::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "rx-err-sec-count", 0, UINT32_MAX, Attributes::RxErrSecCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "rx-err-fcs-count", 0, UINT32_MAX, Attributes::RxErrFcsCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "rx-err-other-count", 0, UINT32_MAX, Attributes::RxErrOtherCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint64_t>>>(Id, "active-timestamp", 0, UINT64_MAX,
                                                                              Attributes::ActiveTimestamp::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint64_t>>>(Id, "pending-timestamp", 0, UINT64_MAX,
                                                                              Attributes::PendingTimestamp::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(Id, "delay", 0, UINT32_MAX, Attributes::Delay::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::Nullable<chip::app::Clusters::ThreadNetworkDiagnostics::Structs::SecurityPolicy::Type>>>(
            Id, "security-policy", Attributes::SecurityPolicy::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::ByteSpan>>>(
            Id, "channel-page0mask", Attributes::ChannelPage0Mask::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::Nullable<
            chip::app::Clusters::ThreadNetworkDiagnostics::Structs::OperationalDatasetComponents::Type>>>(
            Id, "operational-dataset-components", Attributes::OperationalDatasetComponents::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::ThreadNetworkDiagnostics::NetworkFaultEnum>>>(
            Id, "active-network-faults-list", Attributes::ActiveNetworkFaultsList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                            //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                             //
        make_unique<SubscribeAttribute>(Id, "channel", Attributes::Channel::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "routing-role", Attributes::RoutingRole::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "network-name", Attributes::NetworkName::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "pan-id", Attributes::PanId::Id, credsIssuerConfig),                            //
        make_unique<SubscribeAttribute>(Id, "extended-pan-id", Attributes::ExtendedPanId::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "mesh-local-prefix", Attributes::MeshLocalPrefix::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "overrun-count", Attributes::OverrunCount::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "neighbor-table", Attributes::NeighborTable::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "route-table", Attributes::RouteTable::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "partition-id", Attributes::PartitionId::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "weighting", Attributes::Weighting::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "data-version", Attributes::DataVersion::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "stable-data-version", Attributes::StableDataVersion::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "leader-router-id", Attributes::LeaderRouterId::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "detached-role-count", Attributes::DetachedRoleCount::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "child-role-count", Attributes::ChildRoleCount::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "router-role-count", Attributes::RouterRoleCount::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "leader-role-count", Attributes::LeaderRoleCount::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "attach-attempt-count", Attributes::AttachAttemptCount::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "partition-id-change-count", Attributes::PartitionIdChangeCount::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "better-partition-attach-attempt-count",
                                        Attributes::BetterPartitionAttachAttemptCount::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "parent-change-count", Attributes::ParentChangeCount::Id, credsIssuerConfig),      //
        make_unique<SubscribeAttribute>(Id, "tx-total-count", Attributes::TxTotalCount::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "tx-unicast-count", Attributes::TxUnicastCount::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "tx-broadcast-count", Attributes::TxBroadcastCount::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "tx-ack-requested-count", Attributes::TxAckRequestedCount::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "tx-acked-count", Attributes::TxAckedCount::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "tx-no-ack-requested-count", Attributes::TxNoAckRequestedCount::Id,
                                        credsIssuerConfig),                                                                      //
        make_unique<SubscribeAttribute>(Id, "tx-data-count", Attributes::TxDataCount::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "tx-data-poll-count", Attributes::TxDataPollCount::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "tx-beacon-count", Attributes::TxBeaconCount::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "tx-beacon-request-count", Attributes::TxBeaconRequestCount::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "tx-other-count", Attributes::TxOtherCount::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "tx-retry-count", Attributes::TxRetryCount::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "tx-direct-max-retry-expiry-count", Attributes::TxDirectMaxRetryExpiryCount::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "tx-indirect-max-retry-expiry-count", Attributes::TxIndirectMaxRetryExpiryCount::Id,
                                        credsIssuerConfig),                                                            //
        make_unique<SubscribeAttribute>(Id, "tx-err-cca-count", Attributes::TxErrCcaCount::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "tx-err-abort-count", Attributes::TxErrAbortCount::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "tx-err-busy-channel-count", Attributes::TxErrBusyChannelCount::Id,
                                        credsIssuerConfig),                                                                      //
        make_unique<SubscribeAttribute>(Id, "rx-total-count", Attributes::RxTotalCount::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "rx-unicast-count", Attributes::RxUnicastCount::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "rx-broadcast-count", Attributes::RxBroadcastCount::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "rx-data-count", Attributes::RxDataCount::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "rx-data-poll-count", Attributes::RxDataPollCount::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "rx-beacon-count", Attributes::RxBeaconCount::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "rx-beacon-request-count", Attributes::RxBeaconRequestCount::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "rx-other-count", Attributes::RxOtherCount::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "rx-address-filtered-count", Attributes::RxAddressFilteredCount::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "rx-dest-addr-filtered-count", Attributes::RxDestAddrFilteredCount::Id,
                                        credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "rx-duplicated-count", Attributes::RxDuplicatedCount::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "rx-err-no-frame-count", Attributes::RxErrNoFrameCount::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "rx-err-unknown-neighbor-count", Attributes::RxErrUnknownNeighborCount::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "rx-err-invalid-src-addr-count", Attributes::RxErrInvalidSrcAddrCount::Id,
                                        credsIssuerConfig),                                                            //
        make_unique<SubscribeAttribute>(Id, "rx-err-sec-count", Attributes::RxErrSecCount::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "rx-err-fcs-count", Attributes::RxErrFcsCount::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "rx-err-other-count", Attributes::RxErrOtherCount::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "active-timestamp", Attributes::ActiveTimestamp::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "pending-timestamp", Attributes::PendingTimestamp::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "delay", Attributes::Delay::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "security-policy", Attributes::SecurityPolicy::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "channel-page0mask", Attributes::ChannelPage0Mask::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "operational-dataset-components", Attributes::OperationalDatasetComponents::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "active-network-faults-list", Attributes::ActiveNetworkFaultsList::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                              //
        make_unique<ReadEvent>(Id, "connection-status", Events::ConnectionStatus::Id, credsIssuerConfig),           //
        make_unique<ReadEvent>(Id, "network-fault-change", Events::NetworkFaultChange::Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                         //
        make_unique<SubscribeEvent>(Id, "connection-status", Events::ConnectionStatus::Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, "network-fault-change", Events::NetworkFaultChange::Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterWiFiNetworkDiagnostics(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::WiFiNetworkDiagnostics;

    const char * clusterName = "WiFiNetworkDiagnostics";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                //
        make_unique<WiFiNetworkDiagnosticsResetCounts>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                      //
        make_unique<ReadAttribute>(Id, "bssid", Attributes::Bssid::Id, credsIssuerConfig),                                      //
        make_unique<ReadAttribute>(Id, "security-type", Attributes::SecurityType::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "wi-fi-version", Attributes::WiFiVersion::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "channel-number", Attributes::ChannelNumber::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "rssi", Attributes::Rssi::Id, credsIssuerConfig),                                        //
        make_unique<ReadAttribute>(Id, "beacon-lost-count", Attributes::BeaconLostCount::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "beacon-rx-count", Attributes::BeaconRxCount::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "packet-multicast-rx-count", Attributes::PacketMulticastRxCount::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "packet-multicast-tx-count", Attributes::PacketMulticastTxCount::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "packet-unicast-rx-count", Attributes::PacketUnicastRxCount::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "packet-unicast-tx-count", Attributes::PacketUnicastTxCount::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "current-max-rate", Attributes::CurrentMaxRate::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "overrun-count", Attributes::OverrunCount::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig),      //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                             //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                           //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),                 //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                                   //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::ByteSpan>>>(
            Id, "bssid", Attributes::Bssid::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::app::Clusters::WiFiNetworkDiagnostics::SecurityTypeEnum>>>(
            Id, "security-type", 0, UINT8_MAX, Attributes::SecurityType::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::app::Clusters::WiFiNetworkDiagnostics::WiFiVersionEnum>>>(
            Id, "wi-fi-version", 0, UINT8_MAX, Attributes::WiFiVersion::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint16_t>>>(Id, "channel-number", 0, UINT16_MAX,
                                                                              Attributes::ChannelNumber::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int8_t>>>(Id, "rssi", INT8_MIN, INT8_MAX, Attributes::Rssi::Id,
                                                                            WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(Id, "beacon-lost-count", 0, UINT32_MAX,
                                                                              Attributes::BeaconLostCount::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(Id, "beacon-rx-count", 0, UINT32_MAX,
                                                                              Attributes::BeaconRxCount::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(Id, "packet-multicast-rx-count", 0, UINT32_MAX,
                                                                              Attributes::PacketMulticastRxCount::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(Id, "packet-multicast-tx-count", 0, UINT32_MAX,
                                                                              Attributes::PacketMulticastTxCount::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(Id, "packet-unicast-rx-count", 0, UINT32_MAX,
                                                                              Attributes::PacketUnicastRxCount::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(Id, "packet-unicast-tx-count", 0, UINT32_MAX,
                                                                              Attributes::PacketUnicastTxCount::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint64_t>>>(Id, "current-max-rate", 0, UINT64_MAX,
                                                                              Attributes::CurrentMaxRate::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint64_t>>>(
            Id, "overrun-count", 0, UINT64_MAX, Attributes::OverrunCount::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                       //
        make_unique<SubscribeAttribute>(Id, "bssid", Attributes::Bssid::Id, credsIssuerConfig),                       //
        make_unique<SubscribeAttribute>(Id, "security-type", Attributes::SecurityType::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "wi-fi-version", Attributes::WiFiVersion::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "channel-number", Attributes::ChannelNumber::Id, credsIssuerConfig),      //
        make_unique<SubscribeAttribute>(Id, "rssi", Attributes::Rssi::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "beacon-lost-count", Attributes::BeaconLostCount::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "beacon-rx-count", Attributes::BeaconRxCount::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "packet-multicast-rx-count", Attributes::PacketMulticastRxCount::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "packet-multicast-tx-count", Attributes::PacketMulticastTxCount::Id,
                                        credsIssuerConfig),                                                                      //
        make_unique<SubscribeAttribute>(Id, "packet-unicast-rx-count", Attributes::PacketUnicastRxCount::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "packet-unicast-tx-count", Attributes::PacketUnicastTxCount::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "current-max-rate", Attributes::CurrentMaxRate::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "overrun-count", Attributes::OverrunCount::Id, credsIssuerConfig),                   //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig),  //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),    //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                       //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),             //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                             //
        make_unique<ReadEvent>(Id, "disconnection", Events::Disconnection::Id, credsIssuerConfig),                 //
        make_unique<ReadEvent>(Id, "association-failure", Events::AssociationFailure::Id, credsIssuerConfig),      //
        make_unique<ReadEvent>(Id, "connection-status", Events::ConnectionStatus::Id, credsIssuerConfig),          //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                        //
        make_unique<SubscribeEvent>(Id, "disconnection", Events::Disconnection::Id, credsIssuerConfig),            //
        make_unique<SubscribeEvent>(Id, "association-failure", Events::AssociationFailure::Id, credsIssuerConfig), //
        make_unique<SubscribeEvent>(Id, "connection-status", Events::ConnectionStatus::Id, credsIssuerConfig),     //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterEthernetNetworkDiagnostics(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::EthernetNetworkDiagnostics;

    const char * clusterName = "EthernetNetworkDiagnostics";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                    //
        make_unique<EthernetNetworkDiagnosticsResetCounts>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "phyrate", Attributes::PHYRate::Id, credsIssuerConfig),                             //
        make_unique<ReadAttribute>(Id, "full-duplex", Attributes::FullDuplex::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "packet-rx-count", Attributes::PacketRxCount::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "packet-tx-count", Attributes::PacketTxCount::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "tx-err-count", Attributes::TxErrCount::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "collision-count", Attributes::CollisionCount::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "overrun-count", Attributes::OverrunCount::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "carrier-detect", Attributes::CarrierDetect::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "time-since-reset", Attributes::TimeSinceReset::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::app::Clusters::EthernetNetworkDiagnostics::PHYRateEnum>>>(
            Id, "phyrate", 0, UINT8_MAX, Attributes::PHYRate::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<bool>>>(Id, "full-duplex", 0, 1, Attributes::FullDuplex::Id,
                                                                          WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint64_t>>(Id, "packet-rx-count", 0, UINT64_MAX, Attributes::PacketRxCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint64_t>>(Id, "packet-tx-count", 0, UINT64_MAX, Attributes::PacketTxCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint64_t>>(Id, "tx-err-count", 0, UINT64_MAX, Attributes::TxErrCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint64_t>>(Id, "collision-count", 0, UINT64_MAX, Attributes::CollisionCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint64_t>>(Id, "overrun-count", 0, UINT64_MAX, Attributes::OverrunCount::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<bool>>>(Id, "carrier-detect", 0, 1, Attributes::CarrierDetect::Id,
                                                                          WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint64_t>>(Id, "time-since-reset", 0, UINT64_MAX, Attributes::TimeSinceReset::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "phyrate", Attributes::PHYRate::Id, credsIssuerConfig),                             //
        make_unique<SubscribeAttribute>(Id, "full-duplex", Attributes::FullDuplex::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "packet-rx-count", Attributes::PacketRxCount::Id, credsIssuerConfig),               //
        make_unique<SubscribeAttribute>(Id, "packet-tx-count", Attributes::PacketTxCount::Id, credsIssuerConfig),               //
        make_unique<SubscribeAttribute>(Id, "tx-err-count", Attributes::TxErrCount::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "collision-count", Attributes::CollisionCount::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "overrun-count", Attributes::OverrunCount::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "carrier-detect", Attributes::CarrierDetect::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "time-since-reset", Attributes::TimeSinceReset::Id, credsIssuerConfig),             //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterTimeSynchronization(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::TimeSynchronization;

    const char * clusterName = "TimeSynchronization";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                      //
        make_unique<TimeSynchronizationSetUTCTime>(credsIssuerConfig),           //
        make_unique<TimeSynchronizationSetTrustedTimeSource>(credsIssuerConfig), //
        make_unique<TimeSynchronizationSetTimeZone>(credsIssuerConfig),          //
        make_unique<TimeSynchronizationSetDSTOffset>(credsIssuerConfig),         //
        make_unique<TimeSynchronizationSetDefaultNTP>(credsIssuerConfig),        //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                  //
        make_unique<ReadAttribute>(Id, "utctime", Attributes::UTCTime::Id, credsIssuerConfig),                              //
        make_unique<ReadAttribute>(Id, "granularity", Attributes::Granularity::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "time-source", Attributes::TimeSource::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "trusted-time-source", Attributes::TrustedTimeSource::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "default-ntp", Attributes::DefaultNTP::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "time-zone", Attributes::TimeZone::Id, credsIssuerConfig),                           //
        make_unique<ReadAttribute>(Id, "dstoffset", Attributes::DSTOffset::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "local-time", Attributes::LocalTime::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "time-zone-database", Attributes::TimeZoneDatabase::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "ntpserver-available", Attributes::NTPServerAvailable::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "time-zone-list-max-size", Attributes::TimeZoneListMaxSize::Id, credsIssuerConfig),  //
        make_unique<ReadAttribute>(Id, "dstoffset-list-max-size", Attributes::DSTOffsetListMaxSize::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "supports-dnsresolve", Attributes::SupportsDNSResolve::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig),  //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),    //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                 //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),             //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                               //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint64_t>>>(Id, "utctime", 0, UINT64_MAX, Attributes::UTCTime::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::TimeSynchronization::GranularityEnum>>(
            Id, "granularity", 0, UINT8_MAX, Attributes::Granularity::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::TimeSynchronization::TimeSourceEnum>>(
            Id, "time-source", 0, UINT8_MAX, Attributes::TimeSource::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::Nullable<chip::app::Clusters::TimeSynchronization::Structs::TrustedTimeSourceStruct::Type>>>(
            Id, "trusted-time-source", Attributes::TrustedTimeSource::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::CharSpan>>>(
            Id, "default-ntp", Attributes::DefaultNTP::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::TimeSynchronization::Structs::TimeZoneStruct::Type>>>(
            Id, "time-zone", Attributes::TimeZone::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::TimeSynchronization::Structs::DSTOffsetStruct::Type>>>(
            Id, "dstoffset", Attributes::DSTOffset::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint64_t>>>(
            Id, "local-time", 0, UINT64_MAX, Attributes::LocalTime::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::TimeSynchronization::TimeZoneDatabaseEnum>>(
            Id, "time-zone-database", 0, UINT8_MAX, Attributes::TimeZoneDatabase::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<bool>>(Id, "ntpserver-available", 0, 1, Attributes::NTPServerAvailable::Id,
                                          WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "time-zone-list-max-size", 0, UINT8_MAX, Attributes::TimeZoneListMaxSize::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "dstoffset-list-max-size", 0, UINT8_MAX, Attributes::DSTOffsetListMaxSize::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<bool>>(Id, "supports-dnsresolve", 0, 1, Attributes::SupportsDNSResolve::Id,
                                          WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                 //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                  //
        make_unique<SubscribeAttribute>(Id, "utctime", Attributes::UTCTime::Id, credsIssuerConfig),                              //
        make_unique<SubscribeAttribute>(Id, "granularity", Attributes::Granularity::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "time-source", Attributes::TimeSource::Id, credsIssuerConfig),                       //
        make_unique<SubscribeAttribute>(Id, "trusted-time-source", Attributes::TrustedTimeSource::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "default-ntp", Attributes::DefaultNTP::Id, credsIssuerConfig),                       //
        make_unique<SubscribeAttribute>(Id, "time-zone", Attributes::TimeZone::Id, credsIssuerConfig),                           //
        make_unique<SubscribeAttribute>(Id, "dstoffset", Attributes::DSTOffset::Id, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, "local-time", Attributes::LocalTime::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "time-zone-database", Attributes::TimeZoneDatabase::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "ntpserver-available", Attributes::NTPServerAvailable::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "time-zone-list-max-size", Attributes::TimeZoneListMaxSize::Id, credsIssuerConfig),  //
        make_unique<SubscribeAttribute>(Id, "dstoffset-list-max-size", Attributes::DSTOffsetListMaxSize::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "supports-dnsresolve", Attributes::SupportsDNSResolve::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig),  //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),    //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                       //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),             //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                                           //
        make_unique<ReadEvent>(Id, "dsttable-empty", Events::DSTTableEmpty::Id, credsIssuerConfig),                              //
        make_unique<ReadEvent>(Id, "dststatus", Events::DSTStatus::Id, credsIssuerConfig),                                       //
        make_unique<ReadEvent>(Id, "time-zone-status", Events::TimeZoneStatus::Id, credsIssuerConfig),                           //
        make_unique<ReadEvent>(Id, "time-failure", Events::TimeFailure::Id, credsIssuerConfig),                                  //
        make_unique<ReadEvent>(Id, "missing-trusted-time-source", Events::MissingTrustedTimeSource::Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                                      //
        make_unique<SubscribeEvent>(Id, "dsttable-empty", Events::DSTTableEmpty::Id, credsIssuerConfig),                         //
        make_unique<SubscribeEvent>(Id, "dststatus", Events::DSTStatus::Id, credsIssuerConfig),                                  //
        make_unique<SubscribeEvent>(Id, "time-zone-status", Events::TimeZoneStatus::Id, credsIssuerConfig),                      //
        make_unique<SubscribeEvent>(Id, "time-failure", Events::TimeFailure::Id, credsIssuerConfig),                             //
        make_unique<SubscribeEvent>(Id, "missing-trusted-time-source", Events::MissingTrustedTimeSource::Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterBridgedDeviceBasicInformation(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::BridgedDeviceBasicInformation;

    const char * clusterName = "BridgedDeviceBasicInformation";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                   //
        make_unique<ReadAttribute>(Id, "vendor-name", Attributes::VendorName::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "vendor-id", Attributes::VendorID::Id, credsIssuerConfig),                            //
        make_unique<ReadAttribute>(Id, "product-name", Attributes::ProductName::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "node-label", Attributes::NodeLabel::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "hardware-version", Attributes::HardwareVersion::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "hardware-version-string", Attributes::HardwareVersionString::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "software-version", Attributes::SoftwareVersion::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "software-version-string", Attributes::SoftwareVersionString::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "manufacturing-date", Attributes::ManufacturingDate::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "part-number", Attributes::PartNumber::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "product-url", Attributes::ProductURL::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "product-label", Attributes::ProductLabel::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "serial-number", Attributes::SerialNumber::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "reachable", Attributes::Reachable::Id, credsIssuerConfig),                           //
        make_unique<ReadAttribute>(Id, "unique-id", Attributes::UniqueID::Id, credsIssuerConfig),                            //
        make_unique<ReadAttribute>(Id, "product-appearance", Attributes::ProductAppearance::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),              //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                                //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "vendor-name", Attributes::VendorName::Id, WriteCommandType::kForceWrite,
                                                    credsIssuerConfig), //
        make_unique<WriteAttribute<chip::VendorId>>(Id, "vendor-id", 0, UINT16_MAX, Attributes::VendorID::Id,
                                                    WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "product-name", Attributes::ProductName::Id, WriteCommandType::kForceWrite,
                                                    credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "node-label", Attributes::NodeLabel::Id, WriteCommandType::kWrite,
                                                    credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "hardware-version", 0, UINT16_MAX, Attributes::HardwareVersion::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "hardware-version-string", Attributes::HardwareVersionString::Id,
                                                    WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "software-version", 0, UINT32_MAX, Attributes::SoftwareVersion::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "software-version-string", Attributes::SoftwareVersionString::Id,
                                                    WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "manufacturing-date", Attributes::ManufacturingDate::Id,
                                                    WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "part-number", Attributes::PartNumber::Id, WriteCommandType::kForceWrite,
                                                    credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "product-url", Attributes::ProductURL::Id, WriteCommandType::kForceWrite,
                                                    credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "product-label", Attributes::ProductLabel::Id,
                                                    WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "serial-number", Attributes::SerialNumber::Id,
                                                    WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<bool>>(Id, "reachable", 0, 1, Attributes::Reachable::Id, WriteCommandType::kForceWrite,
                                          credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "unique-id", Attributes::UniqueID::Id, WriteCommandType::kForceWrite,
                                                    credsIssuerConfig), //
        make_unique<
            WriteAttributeAsComplex<chip::app::Clusters::BridgedDeviceBasicInformation::Structs::ProductAppearanceStruct::Type>>(
            Id, "product-appearance", Attributes::ProductAppearance::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                  //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                   //
        make_unique<SubscribeAttribute>(Id, "vendor-name", Attributes::VendorName::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "vendor-id", Attributes::VendorID::Id, credsIssuerConfig),                            //
        make_unique<SubscribeAttribute>(Id, "product-name", Attributes::ProductName::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "node-label", Attributes::NodeLabel::Id, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, "hardware-version", Attributes::HardwareVersion::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "hardware-version-string", Attributes::HardwareVersionString::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "software-version", Attributes::SoftwareVersion::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "software-version-string", Attributes::SoftwareVersionString::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "manufacturing-date", Attributes::ManufacturingDate::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "part-number", Attributes::PartNumber::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "product-url", Attributes::ProductURL::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "product-label", Attributes::ProductLabel::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "serial-number", Attributes::SerialNumber::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "reachable", Attributes::Reachable::Id, credsIssuerConfig),                           //
        make_unique<SubscribeAttribute>(Id, "unique-id", Attributes::UniqueID::Id, credsIssuerConfig),                            //
        make_unique<SubscribeAttribute>(Id, "product-appearance", Attributes::ProductAppearance::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),              //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                         //
        make_unique<ReadEvent>(Id, "start-up", Events::StartUp::Id, credsIssuerConfig),                        //
        make_unique<ReadEvent>(Id, "shut-down", Events::ShutDown::Id, credsIssuerConfig),                      //
        make_unique<ReadEvent>(Id, "leave", Events::Leave::Id, credsIssuerConfig),                             //
        make_unique<ReadEvent>(Id, "reachable-changed", Events::ReachableChanged::Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                    //
        make_unique<SubscribeEvent>(Id, "start-up", Events::StartUp::Id, credsIssuerConfig),                   //
        make_unique<SubscribeEvent>(Id, "shut-down", Events::ShutDown::Id, credsIssuerConfig),                 //
        make_unique<SubscribeEvent>(Id, "leave", Events::Leave::Id, credsIssuerConfig),                        //
        make_unique<SubscribeEvent>(Id, "reachable-changed", Events::ReachableChanged::Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterSwitch(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::Switch;

    const char * clusterName = "Switch";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "number-of-positions", Attributes::NumberOfPositions::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "current-position", Attributes::CurrentPosition::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "multi-press-max", Attributes::MultiPressMax::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<uint8_t>>(Id, "number-of-positions", 0, UINT8_MAX, Attributes::NumberOfPositions::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "current-position", 0, UINT8_MAX, Attributes::CurrentPosition::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "multi-press-max", 0, UINT8_MAX, Attributes::MultiPressMax::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "number-of-positions", Attributes::NumberOfPositions::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "current-position", Attributes::CurrentPosition::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "multi-press-max", Attributes::MultiPressMax::Id, credsIssuerConfig),               //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                              //
        make_unique<ReadEvent>(Id, "switch-latched", Events::SwitchLatched::Id, credsIssuerConfig),                 //
        make_unique<ReadEvent>(Id, "initial-press", Events::InitialPress::Id, credsIssuerConfig),                   //
        make_unique<ReadEvent>(Id, "long-press", Events::LongPress::Id, credsIssuerConfig),                         //
        make_unique<ReadEvent>(Id, "short-release", Events::ShortRelease::Id, credsIssuerConfig),                   //
        make_unique<ReadEvent>(Id, "long-release", Events::LongRelease::Id, credsIssuerConfig),                     //
        make_unique<ReadEvent>(Id, "multi-press-ongoing", Events::MultiPressOngoing::Id, credsIssuerConfig),        //
        make_unique<ReadEvent>(Id, "multi-press-complete", Events::MultiPressComplete::Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                         //
        make_unique<SubscribeEvent>(Id, "switch-latched", Events::SwitchLatched::Id, credsIssuerConfig),            //
        make_unique<SubscribeEvent>(Id, "initial-press", Events::InitialPress::Id, credsIssuerConfig),              //
        make_unique<SubscribeEvent>(Id, "long-press", Events::LongPress::Id, credsIssuerConfig),                    //
        make_unique<SubscribeEvent>(Id, "short-release", Events::ShortRelease::Id, credsIssuerConfig),              //
        make_unique<SubscribeEvent>(Id, "long-release", Events::LongRelease::Id, credsIssuerConfig),                //
        make_unique<SubscribeEvent>(Id, "multi-press-ongoing", Events::MultiPressOngoing::Id, credsIssuerConfig),   //
        make_unique<SubscribeEvent>(Id, "multi-press-complete", Events::MultiPressComplete::Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterAdministratorCommissioning(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::AdministratorCommissioning;

    const char * clusterName = "AdministratorCommissioning";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                                     //
        make_unique<AdministratorCommissioningOpenCommissioningWindow>(credsIssuerConfig),      //
        make_unique<AdministratorCommissioningOpenBasicCommissioningWindow>(credsIssuerConfig), //
        make_unique<AdministratorCommissioningRevokeCommissioning>(credsIssuerConfig),          //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "window-status", Attributes::WindowStatus::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "admin-fabric-index", Attributes::AdminFabricIndex::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "admin-vendor-id", Attributes::AdminVendorId::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::app::Clusters::AdministratorCommissioning::CommissioningWindowStatusEnum>>(
            Id, "window-status", 0, UINT8_MAX, Attributes::WindowStatus::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::FabricIndex>>>(
            Id, "admin-fabric-index", 0, UINT8_MAX, Attributes::AdminFabricIndex::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::VendorId>>>(
            Id, "admin-vendor-id", 0, UINT16_MAX, Attributes::AdminVendorId::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "window-status", Attributes::WindowStatus::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "admin-fabric-index", Attributes::AdminFabricIndex::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "admin-vendor-id", Attributes::AdminVendorId::Id, credsIssuerConfig),               //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterOperationalCredentials(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::OperationalCredentials;

    const char * clusterName = "OperationalCredentials";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                              //
        make_unique<OperationalCredentialsAttestationRequest>(credsIssuerConfig),        //
        make_unique<OperationalCredentialsCertificateChainRequest>(credsIssuerConfig),   //
        make_unique<OperationalCredentialsCSRRequest>(credsIssuerConfig),                //
        make_unique<OperationalCredentialsAddNOC>(credsIssuerConfig),                    //
        make_unique<OperationalCredentialsUpdateNOC>(credsIssuerConfig),                 //
        make_unique<OperationalCredentialsUpdateFabricLabel>(credsIssuerConfig),         //
        make_unique<OperationalCredentialsRemoveFabric>(credsIssuerConfig),              //
        make_unique<OperationalCredentialsAddTrustedRootCertificate>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                       //
        make_unique<ReadAttribute>(Id, "nocs", Attributes::NOCs::Id, credsIssuerConfig),                                         //
        make_unique<ReadAttribute>(Id, "fabrics", Attributes::Fabrics::Id, credsIssuerConfig),                                   //
        make_unique<ReadAttribute>(Id, "supported-fabrics", Attributes::SupportedFabrics::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "commissioned-fabrics", Attributes::CommissionedFabrics::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "trusted-root-certificates", Attributes::TrustedRootCertificates::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "current-fabric-index", Attributes::CurrentFabricIndex::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                              //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                            //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),                  //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                                    //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::OperationalCredentials::Structs::NOCStruct::Type>>>(
            Id, "nocs", Attributes::NOCs::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::OperationalCredentials::Structs::FabricDescriptorStruct::Type>>>(
            Id, "fabrics", Attributes::Fabrics::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "supported-fabrics", 0, UINT8_MAX, Attributes::SupportedFabrics::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "commissioned-fabrics", 0, UINT8_MAX, Attributes::CommissionedFabrics::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::ByteSpan>>>(
            Id, "trusted-root-certificates", Attributes::TrustedRootCertificates::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "current-fabric-index", 0, UINT8_MAX, Attributes::CurrentFabricIndex::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                             //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                              //
        make_unique<SubscribeAttribute>(Id, "nocs", Attributes::NOCs::Id, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, "fabrics", Attributes::Fabrics::Id, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, "supported-fabrics", Attributes::SupportedFabrics::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "commissioned-fabrics", Attributes::CommissionedFabrics::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "trusted-root-certificates", Attributes::TrustedRootCertificates::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "current-fabric-index", Attributes::CurrentFabricIndex::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterGroupKeyManagement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::GroupKeyManagement;

    const char * clusterName = "GroupKeyManagement";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                     //
        make_unique<GroupKeyManagementKeySetWrite>(credsIssuerConfig),          //
        make_unique<GroupKeyManagementKeySetRead>(credsIssuerConfig),           //
        make_unique<GroupKeyManagementKeySetRemove>(credsIssuerConfig),         //
        make_unique<GroupKeyManagementKeySetReadAllIndices>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "group-key-map", Attributes::GroupKeyMap::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "group-table", Attributes::GroupTable::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "max-groups-per-fabric", Attributes::MaxGroupsPerFabric::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "max-group-keys-per-fabric", Attributes::MaxGroupKeysPerFabric::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                            //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),                //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                                  //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::GroupKeyManagement::Structs::GroupKeyMapStruct::Type>>>(
            Id, "group-key-map", Attributes::GroupKeyMap::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::GroupKeyManagement::Structs::GroupInfoMapStruct::Type>>>(
            Id, "group-table", Attributes::GroupTable::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "max-groups-per-fabric", 0, UINT16_MAX, Attributes::MaxGroupsPerFabric::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "max-group-keys-per-fabric", 0, UINT16_MAX, Attributes::MaxGroupKeysPerFabric::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                             //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                              //
        make_unique<SubscribeAttribute>(Id, "group-key-map", Attributes::GroupKeyMap::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "group-table", Attributes::GroupTable::Id, credsIssuerConfig),                   //
        make_unique<SubscribeAttribute>(Id, "max-groups-per-fabric", Attributes::MaxGroupsPerFabric::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "max-group-keys-per-fabric", Attributes::MaxGroupKeysPerFabric::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterFixedLabel(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::FixedLabel;

    const char * clusterName = "FixedLabel";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "label-list", Attributes::LabelList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<
            WriteAttributeAsComplex<chip::app::DataModel::List<const chip::app::Clusters::FixedLabel::Structs::LabelStruct::Type>>>(
            Id, "label-list", Attributes::LabelList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "label-list", Attributes::LabelList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterUserLabel(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::UserLabel;

    const char * clusterName = "UserLabel";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "label-list", Attributes::LabelList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<
            WriteAttributeAsComplex<chip::app::DataModel::List<const chip::app::Clusters::UserLabel::Structs::LabelStruct::Type>>>(
            Id, "label-list", Attributes::LabelList::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "label-list", Attributes::LabelList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterProxyConfiguration(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::ProxyConfiguration;

    const char * clusterName = "ProxyConfiguration";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterProxyDiscovery(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::ProxyDiscovery;

    const char * clusterName = "ProxyDiscovery";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterProxyValid(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::ProxyValid;

    const char * clusterName = "ProxyValid";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterBooleanState(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::BooleanState;

    const char * clusterName = "BooleanState";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "state-value", Attributes::StateValue::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<bool>>(Id, "state-value", 0, 1, Attributes::StateValue::Id, WriteCommandType::kForceWrite,
                                          credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "state-value", Attributes::StateValue::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                               //
        make_unique<ReadEvent>(Id, "state-change", Events::StateChange::Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                          //
        make_unique<SubscribeEvent>(Id, "state-change", Events::StateChange::Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterIcdManagement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::IcdManagement;

    const char * clusterName = "IcdManagement";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),             //
        make_unique<IcdManagementRegisterClient>(credsIssuerConfig),    //
        make_unique<IcdManagementUnregisterClient>(credsIssuerConfig),  //
        make_unique<IcdManagementStayActiveRequest>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                               //
        make_unique<ReadAttribute>(Id, "idle-mode-duration", Attributes::IdleModeDuration::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "active-mode-duration", Attributes::ActiveModeDuration::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "active-mode-threshold", Attributes::ActiveModeThreshold::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "registered-clients", Attributes::RegisteredClients::Id, credsIssuerConfig),      //
        make_unique<ReadAttribute>(Id, "icdcounter", Attributes::ICDCounter::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "clients-supported-per-fabric", Attributes::ClientsSupportedPerFabric::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "user-active-mode-trigger-hint", Attributes::UserActiveModeTriggerHint::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "user-active-mode-trigger-instruction", Attributes::UserActiveModeTriggerInstruction::Id,
                                   credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "operating-mode", Attributes::OperatingMode::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<uint32_t>>(Id, "idle-mode-duration", 0, UINT32_MAX, Attributes::IdleModeDuration::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "active-mode-duration", 0, UINT32_MAX, Attributes::ActiveModeDuration::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "active-mode-threshold", 0, UINT16_MAX, Attributes::ActiveModeThreshold::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::IcdManagement::Structs::MonitoringRegistrationStruct::Type>>>(
            Id, "registered-clients", Attributes::RegisteredClients::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "icdcounter", 0, UINT32_MAX, Attributes::ICDCounter::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "clients-supported-per-fabric", 0, UINT16_MAX,
                                              Attributes::ClientsSupportedPerFabric::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::IcdManagement::UserActiveModeTriggerBitmap>>>(
            Id, "user-active-mode-trigger-hint", 0, UINT32_MAX, Attributes::UserActiveModeTriggerHint::Id,
            WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "user-active-mode-trigger-instruction",
                                                    Attributes::UserActiveModeTriggerInstruction::Id, WriteCommandType::kForceWrite,
                                                    credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::IcdManagement::OperatingModeEnum>>(
            Id, "operating-mode", 0, UINT8_MAX, Attributes::OperatingMode::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                              //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                               //
        make_unique<SubscribeAttribute>(Id, "idle-mode-duration", Attributes::IdleModeDuration::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "active-mode-duration", Attributes::ActiveModeDuration::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "active-mode-threshold", Attributes::ActiveModeThreshold::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "registered-clients", Attributes::RegisteredClients::Id, credsIssuerConfig),      //
        make_unique<SubscribeAttribute>(Id, "icdcounter", Attributes::ICDCounter::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "clients-supported-per-fabric", Attributes::ClientsSupportedPerFabric::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "user-active-mode-trigger-hint", Attributes::UserActiveModeTriggerHint::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "user-active-mode-trigger-instruction",
                                        Attributes::UserActiveModeTriggerInstruction::Id, credsIssuerConfig),                   //
        make_unique<SubscribeAttribute>(Id, "operating-mode", Attributes::OperatingMode::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterTimer(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::Timer;

    const char * clusterName = "Timer";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        make_unique<TimerSetTimer>(credsIssuerConfig),      //
        make_unique<TimerResetTimer>(credsIssuerConfig),    //
        make_unique<TimerAddTime>(credsIssuerConfig),       //
        make_unique<TimerReduceTime>(credsIssuerConfig),    //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "set-time", Attributes::SetTime::Id, credsIssuerConfig),                            //
        make_unique<ReadAttribute>(Id, "time-remaining", Attributes::TimeRemaining::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "timer-state", Attributes::TimerState::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<uint32_t>>(Id, "set-time", 0, UINT32_MAX, Attributes::SetTime::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "time-remaining", 0, UINT32_MAX, Attributes::TimeRemaining::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::Timer::TimerStatusEnum>>(
            Id, "timer-state", 0, UINT8_MAX, Attributes::TimerState::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "set-time", Attributes::SetTime::Id, credsIssuerConfig),                            //
        make_unique<SubscribeAttribute>(Id, "time-remaining", Attributes::TimeRemaining::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "timer-state", Attributes::TimerState::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterOvenCavityOperationalState(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::OvenCavityOperationalState;

    const char * clusterName = "OvenCavityOperationalState";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),               //
        make_unique<OvenCavityOperationalStatePause>(credsIssuerConfig),  //
        make_unique<OvenCavityOperationalStateStop>(credsIssuerConfig),   //
        make_unique<OvenCavityOperationalStateStart>(credsIssuerConfig),  //
        make_unique<OvenCavityOperationalStateResume>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "phase-list", Attributes::PhaseList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "current-phase", Attributes::CurrentPhase::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "countdown-time", Attributes::CountdownTime::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "operational-state-list", Attributes::OperationalStateList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "operational-state", Attributes::OperationalState::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "operational-error", Attributes::OperationalError::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::Nullable<chip::app::DataModel::List<const chip::CharSpan>>>>(
            Id, "phase-list", Attributes::PhaseList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(
            Id, "current-phase", 0, UINT8_MAX, Attributes::CurrentPhase::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(Id, "countdown-time", 0, UINT32_MAX,
                                                                              Attributes::CountdownTime::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<
            const chip::app::Clusters::OvenCavityOperationalState::Structs::OperationalStateStruct::Type>>>(
            Id, "operational-state-list", Attributes::OperationalStateList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::OvenCavityOperationalState::OperationalStateEnum>>(
            Id, "operational-state", 0, UINT8_MAX, Attributes::OperationalState::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::Clusters::OvenCavityOperationalState::Structs::ErrorStateStruct::Type>>(
            Id, "operational-error", Attributes::OperationalError::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "phase-list", Attributes::PhaseList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "current-phase", Attributes::CurrentPhase::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "countdown-time", Attributes::CountdownTime::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "operational-state-list", Attributes::OperationalStateList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "operational-state", Attributes::OperationalState::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "operational-error", Attributes::OperationalError::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                               //
        make_unique<ReadEvent>(Id, "operational-error", Events::OperationalError::Id, credsIssuerConfig),            //
        make_unique<ReadEvent>(Id, "operation-completion", Events::OperationCompletion::Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                          //
        make_unique<SubscribeEvent>(Id, "operational-error", Events::OperationalError::Id, credsIssuerConfig),       //
        make_unique<SubscribeEvent>(Id, "operation-completion", Events::OperationCompletion::Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterOvenMode(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::OvenMode;

    const char * clusterName = "OvenMode";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),   //
        make_unique<OvenModeChangeToMode>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "supported-modes", Attributes::SupportedModes::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "current-mode", Attributes::CurrentMode::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "start-up-mode", Attributes::StartUpMode::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "on-mode", Attributes::OnMode::Id, credsIssuerConfig),                              //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::OvenMode::Structs::ModeOptionStruct::Type>>>(
            Id, "supported-modes", Attributes::SupportedModes::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "current-mode", 0, UINT8_MAX, Attributes::CurrentMode::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(
            Id, "start-up-mode", 0, UINT8_MAX, Attributes::StartUpMode::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(Id, "on-mode", 0, UINT8_MAX, Attributes::OnMode::Id,
                                                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "supported-modes", Attributes::SupportedModes::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "current-mode", Attributes::CurrentMode::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "start-up-mode", Attributes::StartUpMode::Id, credsIssuerConfig),                   //
        make_unique<SubscribeAttribute>(Id, "on-mode", Attributes::OnMode::Id, credsIssuerConfig),                              //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterLaundryDryerControls(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::LaundryDryerControls;

    const char * clusterName = "LaundryDryerControls";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "supported-dryness-levels", Attributes::SupportedDrynessLevels::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "selected-dryness-level", Attributes::SelectedDrynessLevel::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                            //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),                //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                                  //
        make_unique<
            WriteAttributeAsComplex<chip::app::DataModel::List<const chip::app::Clusters::LaundryDryerControls::DrynessLevelEnum>>>(
            Id, "supported-dryness-levels", Attributes::SupportedDrynessLevels::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::app::Clusters::LaundryDryerControls::DrynessLevelEnum>>>(
            Id, "selected-dryness-level", 0, UINT8_MAX, Attributes::SelectedDrynessLevel::Id, WriteCommandType::kWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                  //
        make_unique<SubscribeAttribute>(Id, "supported-dryness-levels", Attributes::SupportedDrynessLevels::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "selected-dryness-level", Attributes::SelectedDrynessLevel::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterModeSelect(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::ModeSelect;

    const char * clusterName = "ModeSelect";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),     //
        make_unique<ModeSelectChangeToMode>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "description", Attributes::Description::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "standard-namespace", Attributes::StandardNamespace::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "supported-modes", Attributes::SupportedModes::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "current-mode", Attributes::CurrentMode::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "start-up-mode", Attributes::StartUpMode::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "on-mode", Attributes::OnMode::Id, credsIssuerConfig),                              //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "description", Attributes::Description::Id, WriteCommandType::kForceWrite,
                                                    credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint16_t>>>(Id, "standard-namespace", 0, UINT16_MAX,
                                                                              Attributes::StandardNamespace::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::ModeSelect::Structs::ModeOptionStruct::Type>>>(
            Id, "supported-modes", Attributes::SupportedModes::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "current-mode", 0, UINT8_MAX, Attributes::CurrentMode::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(
            Id, "start-up-mode", 0, UINT8_MAX, Attributes::StartUpMode::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(Id, "on-mode", 0, UINT8_MAX, Attributes::OnMode::Id,
                                                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "description", Attributes::Description::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "standard-namespace", Attributes::StandardNamespace::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "supported-modes", Attributes::SupportedModes::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "current-mode", Attributes::CurrentMode::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "start-up-mode", Attributes::StartUpMode::Id, credsIssuerConfig),                   //
        make_unique<SubscribeAttribute>(Id, "on-mode", Attributes::OnMode::Id, credsIssuerConfig),                              //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterLaundryWasherMode(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::LaundryWasherMode;

    const char * clusterName = "LaundryWasherMode";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),            //
        make_unique<LaundryWasherModeChangeToMode>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "supported-modes", Attributes::SupportedModes::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "current-mode", Attributes::CurrentMode::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "start-up-mode", Attributes::StartUpMode::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "on-mode", Attributes::OnMode::Id, credsIssuerConfig),                              //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::LaundryWasherMode::Structs::ModeOptionStruct::Type>>>(
            Id, "supported-modes", Attributes::SupportedModes::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "current-mode", 0, UINT8_MAX, Attributes::CurrentMode::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(
            Id, "start-up-mode", 0, UINT8_MAX, Attributes::StartUpMode::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(Id, "on-mode", 0, UINT8_MAX, Attributes::OnMode::Id,
                                                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "supported-modes", Attributes::SupportedModes::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "current-mode", Attributes::CurrentMode::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "start-up-mode", Attributes::StartUpMode::Id, credsIssuerConfig),                   //
        make_unique<SubscribeAttribute>(Id, "on-mode", Attributes::OnMode::Id, credsIssuerConfig),                              //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterRefrigeratorAndTemperatureControlledCabinetMode(Commands & commands,
                                                                    CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::RefrigeratorAndTemperatureControlledCabinetMode;

    const char * clusterName = "RefrigeratorAndTemperatureControlledCabinetMode";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                                          //
        make_unique<RefrigeratorAndTemperatureControlledCabinetModeChangeToMode>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "supported-modes", Attributes::SupportedModes::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "current-mode", Attributes::CurrentMode::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "start-up-mode", Attributes::StartUpMode::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "on-mode", Attributes::OnMode::Id, credsIssuerConfig),                              //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<
            const chip::app::Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Structs::ModeOptionStruct::Type>>>(
            Id, "supported-modes", Attributes::SupportedModes::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "current-mode", 0, UINT8_MAX, Attributes::CurrentMode::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(
            Id, "start-up-mode", 0, UINT8_MAX, Attributes::StartUpMode::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(Id, "on-mode", 0, UINT8_MAX, Attributes::OnMode::Id,
                                                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "supported-modes", Attributes::SupportedModes::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "current-mode", Attributes::CurrentMode::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "start-up-mode", Attributes::StartUpMode::Id, credsIssuerConfig),                   //
        make_unique<SubscribeAttribute>(Id, "on-mode", Attributes::OnMode::Id, credsIssuerConfig),                              //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterLaundryWasherControls(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::LaundryWasherControls;

    const char * clusterName = "LaundryWasherControls";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "spin-speeds", Attributes::SpinSpeeds::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "spin-speed-current", Attributes::SpinSpeedCurrent::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "number-of-rinses", Attributes::NumberOfRinses::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "supported-rinses", Attributes::SupportedRinses::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CharSpan>>>(
            Id, "spin-speeds", Attributes::SpinSpeeds::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(Id, "spin-speed-current", 0, UINT8_MAX,
                                                                             Attributes::SpinSpeedCurrent::Id,
                                                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::LaundryWasherControls::NumberOfRinsesEnum>>(
            Id, "number-of-rinses", 0, UINT8_MAX, Attributes::NumberOfRinses::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::LaundryWasherControls::NumberOfRinsesEnum>>>(
            Id, "supported-rinses", Attributes::SupportedRinses::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "spin-speeds", Attributes::SpinSpeeds::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "spin-speed-current", Attributes::SpinSpeedCurrent::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "number-of-rinses", Attributes::NumberOfRinses::Id, credsIssuerConfig),             //
        make_unique<SubscribeAttribute>(Id, "supported-rinses", Attributes::SupportedRinses::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterRvcRunMode(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::RvcRunMode;

    const char * clusterName = "RvcRunMode";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),     //
        make_unique<RvcRunModeChangeToMode>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "supported-modes", Attributes::SupportedModes::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "current-mode", Attributes::CurrentMode::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::RvcRunMode::Structs::ModeOptionStruct::Type>>>(
            Id, "supported-modes", Attributes::SupportedModes::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "current-mode", 0, UINT8_MAX, Attributes::CurrentMode::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "supported-modes", Attributes::SupportedModes::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "current-mode", Attributes::CurrentMode::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterRvcCleanMode(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::RvcCleanMode;

    const char * clusterName = "RvcCleanMode";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),       //
        make_unique<RvcCleanModeChangeToMode>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "supported-modes", Attributes::SupportedModes::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "current-mode", Attributes::CurrentMode::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::RvcCleanMode::Structs::ModeOptionStruct::Type>>>(
            Id, "supported-modes", Attributes::SupportedModes::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "current-mode", 0, UINT8_MAX, Attributes::CurrentMode::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "supported-modes", Attributes::SupportedModes::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "current-mode", Attributes::CurrentMode::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterTemperatureControl(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::TemperatureControl;

    const char * clusterName = "TemperatureControl";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),               //
        make_unique<TemperatureControlSetTemperature>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                              //
        make_unique<ReadAttribute>(Id, "temperature-setpoint", Attributes::TemperatureSetpoint::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "min-temperature", Attributes::MinTemperature::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "max-temperature", Attributes::MaxTemperature::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "step", Attributes::Step::Id, credsIssuerConfig),                                //
        make_unique<ReadAttribute>(Id, "selected-temperature-level", Attributes::SelectedTemperatureLevel::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "supported-temperature-levels", Attributes::SupportedTemperatureLevels::Id,
                                   credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<int16_t>>(Id, "temperature-setpoint", INT16_MIN, INT16_MAX, Attributes::TemperatureSetpoint::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "min-temperature", INT16_MIN, INT16_MAX, Attributes::MinTemperature::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "max-temperature", INT16_MIN, INT16_MAX, Attributes::MaxTemperature::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "step", INT16_MIN, INT16_MAX, Attributes::Step::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "selected-temperature-level", 0, UINT8_MAX,
                                             Attributes::SelectedTemperatureLevel::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CharSpan>>>(
            Id, "supported-temperature-levels", Attributes::SupportedTemperatureLevels::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                             //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                              //
        make_unique<SubscribeAttribute>(Id, "temperature-setpoint", Attributes::TemperatureSetpoint::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "min-temperature", Attributes::MinTemperature::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "max-temperature", Attributes::MaxTemperature::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "step", Attributes::Step::Id, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, "selected-temperature-level", Attributes::SelectedTemperatureLevel::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "supported-temperature-levels", Attributes::SupportedTemperatureLevels::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterRefrigeratorAlarm(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::RefrigeratorAlarm;

    const char * clusterName = "RefrigeratorAlarm";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "mask", Attributes::Mask::Id, credsIssuerConfig),                                   //
        make_unique<ReadAttribute>(Id, "state", Attributes::State::Id, credsIssuerConfig),                                 //
        make_unique<ReadAttribute>(Id, "supported", Attributes::Supported::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap>>>(
            Id, "mask", 0, UINT32_MAX, Attributes::Mask::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap>>>(
            Id, "state", 0, UINT32_MAX, Attributes::State::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::RefrigeratorAlarm::AlarmBitmap>>>(
            Id, "supported", 0, UINT32_MAX, Attributes::Supported::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "mask", Attributes::Mask::Id, credsIssuerConfig),                                   //
        make_unique<SubscribeAttribute>(Id, "state", Attributes::State::Id, credsIssuerConfig),                                 //
        make_unique<SubscribeAttribute>(Id, "supported", Attributes::Supported::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                    //
        make_unique<ReadEvent>(Id, "notify", Events::Notify::Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                               //
        make_unique<SubscribeEvent>(Id, "notify", Events::Notify::Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterDishwasherMode(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::DishwasherMode;

    const char * clusterName = "DishwasherMode";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),         //
        make_unique<DishwasherModeChangeToMode>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "supported-modes", Attributes::SupportedModes::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "current-mode", Attributes::CurrentMode::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "start-up-mode", Attributes::StartUpMode::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "on-mode", Attributes::OnMode::Id, credsIssuerConfig),                              //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::DishwasherMode::Structs::ModeOptionStruct::Type>>>(
            Id, "supported-modes", Attributes::SupportedModes::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "current-mode", 0, UINT8_MAX, Attributes::CurrentMode::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(
            Id, "start-up-mode", 0, UINT8_MAX, Attributes::StartUpMode::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(Id, "on-mode", 0, UINT8_MAX, Attributes::OnMode::Id,
                                                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "supported-modes", Attributes::SupportedModes::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "current-mode", Attributes::CurrentMode::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "start-up-mode", Attributes::StartUpMode::Id, credsIssuerConfig),                   //
        make_unique<SubscribeAttribute>(Id, "on-mode", Attributes::OnMode::Id, credsIssuerConfig),                              //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterAirQuality(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::AirQuality;

    const char * clusterName = "AirQuality";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "air-quality", Attributes::AirQuality::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::app::Clusters::AirQuality::AirQualityEnum>>(
            Id, "air-quality", 0, UINT8_MAX, Attributes::AirQuality::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "air-quality", Attributes::AirQuality::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterSmokeCoAlarm(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::SmokeCoAlarm;

    const char * clusterName = "SmokeCoAlarm";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),          //
        make_unique<SmokeCoAlarmSelfTestRequest>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "expressed-state", Attributes::ExpressedState::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "smoke-state", Attributes::SmokeState::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "costate", Attributes::COState::Id, credsIssuerConfig),                                 //
        make_unique<ReadAttribute>(Id, "battery-alert", Attributes::BatteryAlert::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "device-muted", Attributes::DeviceMuted::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "test-in-progress", Attributes::TestInProgress::Id, credsIssuerConfig),                 //
        make_unique<ReadAttribute>(Id, "hardware-fault-alert", Attributes::HardwareFaultAlert::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "end-of-service-alert", Attributes::EndOfServiceAlert::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "interconnect-smoke-alarm", Attributes::InterconnectSmokeAlarm::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "interconnect-coalarm", Attributes::InterconnectCOAlarm::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "contamination-state", Attributes::ContaminationState::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "smoke-sensitivity-level", Attributes::SmokeSensitivityLevel::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "expiry-date", Attributes::ExpiryDate::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                            //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),                //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                                  //
        make_unique<WriteAttribute<chip::app::Clusters::SmokeCoAlarm::ExpressedStateEnum>>(
            Id, "expressed-state", 0, UINT8_MAX, Attributes::ExpressedState::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>>(
            Id, "smoke-state", 0, UINT8_MAX, Attributes::SmokeState::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>>(
            Id, "costate", 0, UINT8_MAX, Attributes::COState::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>>(
            Id, "battery-alert", 0, UINT8_MAX, Attributes::BatteryAlert::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::SmokeCoAlarm::MuteStateEnum>>(
            Id, "device-muted", 0, UINT8_MAX, Attributes::DeviceMuted::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<bool>>(Id, "test-in-progress", 0, 1, Attributes::TestInProgress::Id,
                                          WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<bool>>(Id, "hardware-fault-alert", 0, 1, Attributes::HardwareFaultAlert::Id,
                                          WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::SmokeCoAlarm::EndOfServiceEnum>>(
            Id, "end-of-service-alert", 0, UINT8_MAX, Attributes::EndOfServiceAlert::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>>(
            Id, "interconnect-smoke-alarm", 0, UINT8_MAX, Attributes::InterconnectSmokeAlarm::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum>>(
            Id, "interconnect-coalarm", 0, UINT8_MAX, Attributes::InterconnectCOAlarm::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::SmokeCoAlarm::ContaminationStateEnum>>(
            Id, "contamination-state", 0, UINT8_MAX, Attributes::ContaminationState::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::SmokeCoAlarm::SensitivityEnum>>(
            Id, "smoke-sensitivity-level", 0, UINT8_MAX, Attributes::SmokeSensitivityLevel::Id, WriteCommandType::kWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "expiry-date", 0, UINT32_MAX, Attributes::ExpiryDate::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                            //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                             //
        make_unique<SubscribeAttribute>(Id, "expressed-state", Attributes::ExpressedState::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "smoke-state", Attributes::SmokeState::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "costate", Attributes::COState::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "battery-alert", Attributes::BatteryAlert::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "device-muted", Attributes::DeviceMuted::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "test-in-progress", Attributes::TestInProgress::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "hardware-fault-alert", Attributes::HardwareFaultAlert::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "end-of-service-alert", Attributes::EndOfServiceAlert::Id, credsIssuerConfig),  //
        make_unique<SubscribeAttribute>(Id, "interconnect-smoke-alarm", Attributes::InterconnectSmokeAlarm::Id,
                                        credsIssuerConfig),                                                                       //
        make_unique<SubscribeAttribute>(Id, "interconnect-coalarm", Attributes::InterconnectCOAlarm::Id, credsIssuerConfig),      //
        make_unique<SubscribeAttribute>(Id, "contamination-state", Attributes::ContaminationState::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "smoke-sensitivity-level", Attributes::SmokeSensitivityLevel::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "expiry-date", Attributes::ExpiryDate::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),              //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                                      //
        make_unique<ReadEvent>(Id, "smoke-alarm", Events::SmokeAlarm::Id, credsIssuerConfig),                               //
        make_unique<ReadEvent>(Id, "coalarm", Events::COAlarm::Id, credsIssuerConfig),                                      //
        make_unique<ReadEvent>(Id, "low-battery", Events::LowBattery::Id, credsIssuerConfig),                               //
        make_unique<ReadEvent>(Id, "hardware-fault", Events::HardwareFault::Id, credsIssuerConfig),                         //
        make_unique<ReadEvent>(Id, "end-of-service", Events::EndOfService::Id, credsIssuerConfig),                          //
        make_unique<ReadEvent>(Id, "self-test-complete", Events::SelfTestComplete::Id, credsIssuerConfig),                  //
        make_unique<ReadEvent>(Id, "alarm-muted", Events::AlarmMuted::Id, credsIssuerConfig),                               //
        make_unique<ReadEvent>(Id, "mute-ended", Events::MuteEnded::Id, credsIssuerConfig),                                 //
        make_unique<ReadEvent>(Id, "interconnect-smoke-alarm", Events::InterconnectSmokeAlarm::Id, credsIssuerConfig),      //
        make_unique<ReadEvent>(Id, "interconnect-coalarm", Events::InterconnectCOAlarm::Id, credsIssuerConfig),             //
        make_unique<ReadEvent>(Id, "all-clear", Events::AllClear::Id, credsIssuerConfig),                                   //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeEvent>(Id, "smoke-alarm", Events::SmokeAlarm::Id, credsIssuerConfig),                          //
        make_unique<SubscribeEvent>(Id, "coalarm", Events::COAlarm::Id, credsIssuerConfig),                                 //
        make_unique<SubscribeEvent>(Id, "low-battery", Events::LowBattery::Id, credsIssuerConfig),                          //
        make_unique<SubscribeEvent>(Id, "hardware-fault", Events::HardwareFault::Id, credsIssuerConfig),                    //
        make_unique<SubscribeEvent>(Id, "end-of-service", Events::EndOfService::Id, credsIssuerConfig),                     //
        make_unique<SubscribeEvent>(Id, "self-test-complete", Events::SelfTestComplete::Id, credsIssuerConfig),             //
        make_unique<SubscribeEvent>(Id, "alarm-muted", Events::AlarmMuted::Id, credsIssuerConfig),                          //
        make_unique<SubscribeEvent>(Id, "mute-ended", Events::MuteEnded::Id, credsIssuerConfig),                            //
        make_unique<SubscribeEvent>(Id, "interconnect-smoke-alarm", Events::InterconnectSmokeAlarm::Id, credsIssuerConfig), //
        make_unique<SubscribeEvent>(Id, "interconnect-coalarm", Events::InterconnectCOAlarm::Id, credsIssuerConfig),        //
        make_unique<SubscribeEvent>(Id, "all-clear", Events::AllClear::Id, credsIssuerConfig),                              //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterDishwasherAlarm(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::DishwasherAlarm;

    const char * clusterName = "DishwasherAlarm";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                 //
        make_unique<DishwasherAlarmReset>(credsIssuerConfig),               //
        make_unique<DishwasherAlarmModifyEnabledAlarms>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "mask", Attributes::Mask::Id, credsIssuerConfig),                                   //
        make_unique<ReadAttribute>(Id, "latch", Attributes::Latch::Id, credsIssuerConfig),                                 //
        make_unique<ReadAttribute>(Id, "state", Attributes::State::Id, credsIssuerConfig),                                 //
        make_unique<ReadAttribute>(Id, "supported", Attributes::Supported::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap>>>(
            Id, "mask", 0, UINT32_MAX, Attributes::Mask::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap>>>(
            Id, "latch", 0, UINT32_MAX, Attributes::Latch::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap>>>(
            Id, "state", 0, UINT32_MAX, Attributes::State::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::DishwasherAlarm::AlarmBitmap>>>(
            Id, "supported", 0, UINT32_MAX, Attributes::Supported::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "mask", Attributes::Mask::Id, credsIssuerConfig),                                   //
        make_unique<SubscribeAttribute>(Id, "latch", Attributes::Latch::Id, credsIssuerConfig),                                 //
        make_unique<SubscribeAttribute>(Id, "state", Attributes::State::Id, credsIssuerConfig),                                 //
        make_unique<SubscribeAttribute>(Id, "supported", Attributes::Supported::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                    //
        make_unique<ReadEvent>(Id, "notify", Events::Notify::Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                               //
        make_unique<SubscribeEvent>(Id, "notify", Events::Notify::Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterMicrowaveOvenMode(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::MicrowaveOvenMode;

    const char * clusterName = "MicrowaveOvenMode";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "supported-modes", Attributes::SupportedModes::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "current-mode", Attributes::CurrentMode::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::MicrowaveOvenMode::Structs::ModeOptionStruct::Type>>>(
            Id, "supported-modes", Attributes::SupportedModes::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "current-mode", 0, UINT8_MAX, Attributes::CurrentMode::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "supported-modes", Attributes::SupportedModes::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "current-mode", Attributes::CurrentMode::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterMicrowaveOvenControl(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::MicrowaveOvenControl;

    const char * clusterName = "MicrowaveOvenControl";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                       //
        make_unique<MicrowaveOvenControlSetCookingParameters>(credsIssuerConfig), //
        make_unique<MicrowaveOvenControlAddMoreTime>(credsIssuerConfig),          //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "cook-time", Attributes::CookTime::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "max-cook-time", Attributes::MaxCookTime::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "power-setting", Attributes::PowerSetting::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "min-power", Attributes::MinPower::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "max-power", Attributes::MaxPower::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "power-step", Attributes::PowerStep::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "supported-watts", Attributes::SupportedWatts::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "selected-watt-index", Attributes::SelectedWattIndex::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "watt-rating", Attributes::WattRating::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<uint32_t>>(Id, "cook-time", 0, UINT32_MAX, Attributes::CookTime::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "max-cook-time", 0, UINT32_MAX, Attributes::MaxCookTime::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "power-setting", 0, UINT8_MAX, Attributes::PowerSetting::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "min-power", 0, UINT8_MAX, Attributes::MinPower::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "max-power", 0, UINT8_MAX, Attributes::MaxPower::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "power-step", 0, UINT8_MAX, Attributes::PowerStep::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const uint16_t>>>(
            Id, "supported-watts", Attributes::SupportedWatts::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "selected-watt-index", 0, UINT8_MAX, Attributes::SelectedWattIndex::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "watt-rating", 0, UINT16_MAX, Attributes::WattRating::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "cook-time", Attributes::CookTime::Id, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, "max-cook-time", Attributes::MaxCookTime::Id, credsIssuerConfig),                   //
        make_unique<SubscribeAttribute>(Id, "power-setting", Attributes::PowerSetting::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "min-power", Attributes::MinPower::Id, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, "max-power", Attributes::MaxPower::Id, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, "power-step", Attributes::PowerStep::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "supported-watts", Attributes::SupportedWatts::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "selected-watt-index", Attributes::SelectedWattIndex::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "watt-rating", Attributes::WattRating::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterOperationalState(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::OperationalState;

    const char * clusterName = "OperationalState";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),     //
        make_unique<OperationalStatePause>(credsIssuerConfig),  //
        make_unique<OperationalStateStop>(credsIssuerConfig),   //
        make_unique<OperationalStateStart>(credsIssuerConfig),  //
        make_unique<OperationalStateResume>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "phase-list", Attributes::PhaseList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "current-phase", Attributes::CurrentPhase::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "countdown-time", Attributes::CountdownTime::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "operational-state-list", Attributes::OperationalStateList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "operational-state", Attributes::OperationalState::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "operational-error", Attributes::OperationalError::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::Nullable<chip::app::DataModel::List<const chip::CharSpan>>>>(
            Id, "phase-list", Attributes::PhaseList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(
            Id, "current-phase", 0, UINT8_MAX, Attributes::CurrentPhase::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(Id, "countdown-time", 0, UINT32_MAX,
                                                                              Attributes::CountdownTime::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::OperationalState::Structs::OperationalStateStruct::Type>>>(
            Id, "operational-state-list", Attributes::OperationalStateList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::OperationalState::OperationalStateEnum>>(
            Id, "operational-state", 0, UINT8_MAX, Attributes::OperationalState::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::Clusters::OperationalState::Structs::ErrorStateStruct::Type>>(
            Id, "operational-error", Attributes::OperationalError::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "phase-list", Attributes::PhaseList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "current-phase", Attributes::CurrentPhase::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "countdown-time", Attributes::CountdownTime::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "operational-state-list", Attributes::OperationalStateList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "operational-state", Attributes::OperationalState::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "operational-error", Attributes::OperationalError::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                               //
        make_unique<ReadEvent>(Id, "operational-error", Events::OperationalError::Id, credsIssuerConfig),            //
        make_unique<ReadEvent>(Id, "operation-completion", Events::OperationCompletion::Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                          //
        make_unique<SubscribeEvent>(Id, "operational-error", Events::OperationalError::Id, credsIssuerConfig),       //
        make_unique<SubscribeEvent>(Id, "operation-completion", Events::OperationCompletion::Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterRvcOperationalState(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::RvcOperationalState;

    const char * clusterName = "RvcOperationalState";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),        //
        make_unique<RvcOperationalStatePause>(credsIssuerConfig),  //
        make_unique<RvcOperationalStateResume>(credsIssuerConfig), //
        make_unique<RvcOperationalStateGoHome>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "phase-list", Attributes::PhaseList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "current-phase", Attributes::CurrentPhase::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "countdown-time", Attributes::CountdownTime::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "operational-state-list", Attributes::OperationalStateList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "operational-state", Attributes::OperationalState::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "operational-error", Attributes::OperationalError::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::Nullable<chip::app::DataModel::List<const chip::CharSpan>>>>(
            Id, "phase-list", Attributes::PhaseList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(
            Id, "current-phase", 0, UINT8_MAX, Attributes::CurrentPhase::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(Id, "countdown-time", 0, UINT32_MAX,
                                                                              Attributes::CountdownTime::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::RvcOperationalState::Structs::OperationalStateStruct::Type>>>(
            Id, "operational-state-list", Attributes::OperationalStateList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "operational-state", 0, UINT8_MAX, Attributes::OperationalState::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::Clusters::RvcOperationalState::Structs::ErrorStateStruct::Type>>(
            Id, "operational-error", Attributes::OperationalError::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "phase-list", Attributes::PhaseList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "current-phase", Attributes::CurrentPhase::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "countdown-time", Attributes::CountdownTime::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "operational-state-list", Attributes::OperationalStateList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "operational-state", Attributes::OperationalState::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "operational-error", Attributes::OperationalError::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                               //
        make_unique<ReadEvent>(Id, "operational-error", Events::OperationalError::Id, credsIssuerConfig),            //
        make_unique<ReadEvent>(Id, "operation-completion", Events::OperationCompletion::Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                          //
        make_unique<SubscribeEvent>(Id, "operational-error", Events::OperationalError::Id, credsIssuerConfig),       //
        make_unique<SubscribeEvent>(Id, "operation-completion", Events::OperationCompletion::Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterScenesManagement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::ScenesManagement;

    const char * clusterName = "ScenesManagement";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                 //
        make_unique<ScenesManagementAddScene>(credsIssuerConfig),           //
        make_unique<ScenesManagementViewScene>(credsIssuerConfig),          //
        make_unique<ScenesManagementRemoveScene>(credsIssuerConfig),        //
        make_unique<ScenesManagementRemoveAllScenes>(credsIssuerConfig),    //
        make_unique<ScenesManagementStoreScene>(credsIssuerConfig),         //
        make_unique<ScenesManagementRecallScene>(credsIssuerConfig),        //
        make_unique<ScenesManagementGetSceneMembership>(credsIssuerConfig), //
        make_unique<ScenesManagementCopyScene>(credsIssuerConfig),          //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "last-configured-by", Attributes::LastConfiguredBy::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "scene-table-size", Attributes::SceneTableSize::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "fabric-scene-info", Attributes::FabricSceneInfo::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::NodeId>>>(
            Id, "last-configured-by", 0, UINT64_MAX, Attributes::LastConfiguredBy::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "scene-table-size", 0, UINT16_MAX, Attributes::SceneTableSize::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::ScenesManagement::Structs::SceneInfoStruct::Type>>>(
            Id, "fabric-scene-info", Attributes::FabricSceneInfo::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "last-configured-by", Attributes::LastConfiguredBy::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "scene-table-size", Attributes::SceneTableSize::Id, credsIssuerConfig),             //
        make_unique<SubscribeAttribute>(Id, "fabric-scene-info", Attributes::FabricSceneInfo::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterHepaFilterMonitoring(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::HepaFilterMonitoring;

    const char * clusterName = "HepaFilterMonitoring";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                 //
        make_unique<HepaFilterMonitoringResetCondition>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "condition", Attributes::Condition::Id, credsIssuerConfig),                             //
        make_unique<ReadAttribute>(Id, "degradation-direction", Attributes::DegradationDirection::Id, credsIssuerConfig),      //
        make_unique<ReadAttribute>(Id, "change-indication", Attributes::ChangeIndication::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "in-place-indicator", Attributes::InPlaceIndicator::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "last-changed-time", Attributes::LastChangedTime::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "replacement-product-list", Attributes::ReplacementProductList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                            //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),                //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                                  //
        make_unique<WriteAttribute<chip::Percent>>(Id, "condition", 0, UINT8_MAX, Attributes::Condition::Id,
                                                   WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::HepaFilterMonitoring::DegradationDirectionEnum>>(
            Id, "degradation-direction", 0, UINT8_MAX, Attributes::DegradationDirection::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::HepaFilterMonitoring::ChangeIndicationEnum>>(
            Id, "change-indication", 0, UINT8_MAX, Attributes::ChangeIndication::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<bool>>(Id, "in-place-indicator", 0, 1, Attributes::InPlaceIndicator::Id,
                                          WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(Id, "last-changed-time", 0, UINT32_MAX,
                                                                              Attributes::LastChangedTime::Id,
                                                                              WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::HepaFilterMonitoring::Structs::ReplacementProductStruct::Type>>>(
            Id, "replacement-product-list", Attributes::ReplacementProductList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                               //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                //
        make_unique<SubscribeAttribute>(Id, "condition", Attributes::Condition::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "degradation-direction", Attributes::DegradationDirection::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "change-indication", Attributes::ChangeIndication::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "in-place-indicator", Attributes::InPlaceIndicator::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "last-changed-time", Attributes::LastChangedTime::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "replacement-product-list", Attributes::ReplacementProductList::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterActivatedCarbonFilterMonitoring(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::ActivatedCarbonFilterMonitoring;

    const char * clusterName = "ActivatedCarbonFilterMonitoring";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                            //
        make_unique<ActivatedCarbonFilterMonitoringResetCondition>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "condition", Attributes::Condition::Id, credsIssuerConfig),                             //
        make_unique<ReadAttribute>(Id, "degradation-direction", Attributes::DegradationDirection::Id, credsIssuerConfig),      //
        make_unique<ReadAttribute>(Id, "change-indication", Attributes::ChangeIndication::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "in-place-indicator", Attributes::InPlaceIndicator::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "last-changed-time", Attributes::LastChangedTime::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "replacement-product-list", Attributes::ReplacementProductList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                            //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),                //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                                  //
        make_unique<WriteAttribute<chip::Percent>>(Id, "condition", 0, UINT8_MAX, Attributes::Condition::Id,
                                                   WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::ActivatedCarbonFilterMonitoring::DegradationDirectionEnum>>(
            Id, "degradation-direction", 0, UINT8_MAX, Attributes::DegradationDirection::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::ActivatedCarbonFilterMonitoring::ChangeIndicationEnum>>(
            Id, "change-indication", 0, UINT8_MAX, Attributes::ChangeIndication::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<bool>>(Id, "in-place-indicator", 0, 1, Attributes::InPlaceIndicator::Id,
                                          WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(Id, "last-changed-time", 0, UINT32_MAX,
                                                                              Attributes::LastChangedTime::Id,
                                                                              WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<
            const chip::app::Clusters::ActivatedCarbonFilterMonitoring::Structs::ReplacementProductStruct::Type>>>(
            Id, "replacement-product-list", Attributes::ReplacementProductList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                               //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                //
        make_unique<SubscribeAttribute>(Id, "condition", Attributes::Condition::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "degradation-direction", Attributes::DegradationDirection::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "change-indication", Attributes::ChangeIndication::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "in-place-indicator", Attributes::InPlaceIndicator::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "last-changed-time", Attributes::LastChangedTime::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "replacement-product-list", Attributes::ReplacementProductList::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterBooleanStateConfiguration(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::BooleanStateConfiguration;

    const char * clusterName = "BooleanStateConfiguration";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                          //
        make_unique<BooleanStateConfigurationSuppressAlarm>(credsIssuerConfig),      //
        make_unique<BooleanStateConfigurationEnableDisableAlarm>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                       //
        make_unique<ReadAttribute>(Id, "current-sensitivity-level", Attributes::CurrentSensitivityLevel::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "supported-sensitivity-levels", Attributes::SupportedSensitivityLevels::Id,
                                   credsIssuerConfig),                                                                           //
        make_unique<ReadAttribute>(Id, "default-sensitivity-level", Attributes::DefaultSensitivityLevel::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "alarms-active", Attributes::AlarmsActive::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "alarms-suppressed", Attributes::AlarmsSuppressed::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "alarms-enabled", Attributes::AlarmsEnabled::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "alarms-supported", Attributes::AlarmsSupported::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "sensor-fault", Attributes::SensorFault::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                              //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                            //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),                  //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                                    //
        make_unique<WriteAttribute<uint8_t>>(Id, "current-sensitivity-level", 0, UINT8_MAX, Attributes::CurrentSensitivityLevel::Id,
                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "supported-sensitivity-levels", 0, UINT8_MAX,
                                             Attributes::SupportedSensitivityLevels::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "default-sensitivity-level", 0, UINT8_MAX, Attributes::DefaultSensitivityLevel::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap>>>(
            Id, "alarms-active", 0, UINT8_MAX, Attributes::AlarmsActive::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap>>>(
            Id, "alarms-suppressed", 0, UINT8_MAX, Attributes::AlarmsSuppressed::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap>>>(
            Id, "alarms-enabled", 0, UINT8_MAX, Attributes::AlarmsEnabled::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::AlarmModeBitmap>>>(
            Id, "alarms-supported", 0, UINT8_MAX, Attributes::AlarmsSupported::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::BooleanStateConfiguration::SensorFaultBitmap>>>(
            Id, "sensor-fault", 0, UINT16_MAX, Attributes::SensorFault::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                  //
        make_unique<SubscribeAttribute>(Id, "current-sensitivity-level", Attributes::CurrentSensitivityLevel::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "supported-sensitivity-levels", Attributes::SupportedSensitivityLevels::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "default-sensitivity-level", Attributes::DefaultSensitivityLevel::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "alarms-active", Attributes::AlarmsActive::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "alarms-suppressed", Attributes::AlarmsSuppressed::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "alarms-enabled", Attributes::AlarmsEnabled::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "alarms-supported", Attributes::AlarmsSupported::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "sensor-fault", Attributes::SensorFault::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                              //
        make_unique<ReadEvent>(Id, "alarms-state-changed", Events::AlarmsStateChanged::Id, credsIssuerConfig),      //
        make_unique<ReadEvent>(Id, "sensor-fault", Events::SensorFault::Id, credsIssuerConfig),                     //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                         //
        make_unique<SubscribeEvent>(Id, "alarms-state-changed", Events::AlarmsStateChanged::Id, credsIssuerConfig), //
        make_unique<SubscribeEvent>(Id, "sensor-fault", Events::SensorFault::Id, credsIssuerConfig),                //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterValveConfigurationAndControl(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::ValveConfigurationAndControl;

    const char * clusterName = "ValveConfigurationAndControl";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                //
        make_unique<ValveConfigurationAndControlOpen>(credsIssuerConfig),  //
        make_unique<ValveConfigurationAndControlClose>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "open-duration", Attributes::OpenDuration::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "default-open-duration", Attributes::DefaultOpenDuration::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "auto-close-time", Attributes::AutoCloseTime::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "remaining-duration", Attributes::RemainingDuration::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "current-state", Attributes::CurrentState::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "target-state", Attributes::TargetState::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "current-level", Attributes::CurrentLevel::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "target-level", Attributes::TargetLevel::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "default-open-level", Attributes::DefaultOpenLevel::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "valve-fault", Attributes::ValveFault::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "level-step", Attributes::LevelStep::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(
            Id, "open-duration", 0, UINT32_MAX, Attributes::OpenDuration::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(Id, "default-open-duration", 0, UINT32_MAX,
                                                                              Attributes::DefaultOpenDuration::Id,
                                                                              WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint64_t>>>(Id, "auto-close-time", 0, UINT64_MAX,
                                                                              Attributes::AutoCloseTime::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(Id, "remaining-duration", 0, UINT32_MAX,
                                                                              Attributes::RemainingDuration::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<
            WriteAttribute<chip::app::DataModel::Nullable<chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum>>>(
            Id, "current-state", 0, UINT8_MAX, Attributes::CurrentState::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<
            WriteAttribute<chip::app::DataModel::Nullable<chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum>>>(
            Id, "target-state", 0, UINT8_MAX, Attributes::TargetState::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::Percent>>>(
            Id, "current-level", 0, UINT8_MAX, Attributes::CurrentLevel::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::Percent>>>(
            Id, "target-level", 0, UINT8_MAX, Attributes::TargetLevel::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::Percent>>(Id, "default-open-level", 0, UINT8_MAX, Attributes::DefaultOpenLevel::Id,
                                                   WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::ValveConfigurationAndControl::ValveFaultBitmap>>>(
            Id, "valve-fault", 0, UINT16_MAX, Attributes::ValveFault::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "level-step", 0, UINT8_MAX, Attributes::LevelStep::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "open-duration", Attributes::OpenDuration::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "default-open-duration", Attributes::DefaultOpenDuration::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "auto-close-time", Attributes::AutoCloseTime::Id, credsIssuerConfig),               //
        make_unique<SubscribeAttribute>(Id, "remaining-duration", Attributes::RemainingDuration::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "current-state", Attributes::CurrentState::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "target-state", Attributes::TargetState::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "current-level", Attributes::CurrentLevel::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "target-level", Attributes::TargetLevel::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "default-open-level", Attributes::DefaultOpenLevel::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "valve-fault", Attributes::ValveFault::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "level-step", Attributes::LevelStep::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                            //
        make_unique<ReadEvent>(Id, "valve-state-changed", Events::ValveStateChanged::Id, credsIssuerConfig),      //
        make_unique<ReadEvent>(Id, "valve-fault", Events::ValveFault::Id, credsIssuerConfig),                     //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                       //
        make_unique<SubscribeEvent>(Id, "valve-state-changed", Events::ValveStateChanged::Id, credsIssuerConfig), //
        make_unique<SubscribeEvent>(Id, "valve-fault", Events::ValveFault::Id, credsIssuerConfig),                //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterElectricalPowerMeasurement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::ElectricalPowerMeasurement;

    const char * clusterName = "ElectricalPowerMeasurement";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                          //
        make_unique<ReadAttribute>(Id, "power-mode", Attributes::PowerMode::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "number-of-measurement-types", Attributes::NumberOfMeasurementTypes::Id,
                                   credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "accuracy", Attributes::Accuracy::Id, credsIssuerConfig),                           //
        make_unique<ReadAttribute>(Id, "ranges", Attributes::Ranges::Id, credsIssuerConfig),                               //
        make_unique<ReadAttribute>(Id, "voltage", Attributes::Voltage::Id, credsIssuerConfig),                             //
        make_unique<ReadAttribute>(Id, "active-current", Attributes::ActiveCurrent::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "reactive-current", Attributes::ReactiveCurrent::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "apparent-current", Attributes::ApparentCurrent::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "active-power", Attributes::ActivePower::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "reactive-power", Attributes::ReactivePower::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "apparent-power", Attributes::ApparentPower::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "rmsvoltage", Attributes::RMSVoltage::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "rmscurrent", Attributes::RMSCurrent::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "rmspower", Attributes::RMSPower::Id, credsIssuerConfig),                           //
        make_unique<ReadAttribute>(Id, "frequency", Attributes::Frequency::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "harmonic-currents", Attributes::HarmonicCurrents::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "harmonic-phases", Attributes::HarmonicPhases::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "power-factor", Attributes::PowerFactor::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "neutral-current", Attributes::NeutralCurrent::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::app::Clusters::ElectricalPowerMeasurement::PowerModeEnum>>(
            Id, "power-mode", 0, UINT8_MAX, Attributes::PowerMode::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "number-of-measurement-types", 0, UINT8_MAX,
                                             Attributes::NumberOfMeasurementTypes::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<
            const chip::app::Clusters::ElectricalPowerMeasurement::Structs::MeasurementAccuracyStruct::Type>>>(
            Id, "accuracy", Attributes::Accuracy::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<
            const chip::app::Clusters::ElectricalPowerMeasurement::Structs::MeasurementRangeStruct::Type>>>(
            Id, "ranges", Attributes::Ranges::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int64_t>>>(
            Id, "voltage", INT64_MIN, INT64_MAX, Attributes::Voltage::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int64_t>>>(Id, "active-current", INT64_MIN, INT64_MAX,
                                                                             Attributes::ActiveCurrent::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int64_t>>>(Id, "reactive-current", INT64_MIN, INT64_MAX,
                                                                             Attributes::ReactiveCurrent::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int64_t>>>(Id, "apparent-current", INT64_MIN, INT64_MAX,
                                                                             Attributes::ApparentCurrent::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int64_t>>>(Id, "active-power", INT64_MIN, INT64_MAX,
                                                                             Attributes::ActivePower::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int64_t>>>(Id, "reactive-power", INT64_MIN, INT64_MAX,
                                                                             Attributes::ReactivePower::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int64_t>>>(Id, "apparent-power", INT64_MIN, INT64_MAX,
                                                                             Attributes::ApparentPower::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int64_t>>>(Id, "rmsvoltage", INT64_MIN, INT64_MAX,
                                                                             Attributes::RMSVoltage::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int64_t>>>(Id, "rmscurrent", INT64_MIN, INT64_MAX,
                                                                             Attributes::RMSCurrent::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int64_t>>>(
            Id, "rmspower", INT64_MIN, INT64_MAX, Attributes::RMSPower::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int64_t>>>(
            Id, "frequency", INT64_MIN, INT64_MAX, Attributes::Frequency::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::Nullable<chip::app::DataModel::List<
            const chip::app::Clusters::ElectricalPowerMeasurement::Structs::HarmonicMeasurementStruct::Type>>>>(
            Id, "harmonic-currents", Attributes::HarmonicCurrents::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::Nullable<chip::app::DataModel::List<
            const chip::app::Clusters::ElectricalPowerMeasurement::Structs::HarmonicMeasurementStruct::Type>>>>(
            Id, "harmonic-phases", Attributes::HarmonicPhases::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int64_t>>>(Id, "power-factor", INT64_MIN, INT64_MAX,
                                                                             Attributes::PowerFactor::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int64_t>>>(Id, "neutral-current", INT64_MIN, INT64_MAX,
                                                                             Attributes::NeutralCurrent::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                          //
        make_unique<SubscribeAttribute>(Id, "power-mode", Attributes::PowerMode::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "number-of-measurement-types", Attributes::NumberOfMeasurementTypes::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "accuracy", Attributes::Accuracy::Id, credsIssuerConfig),                           //
        make_unique<SubscribeAttribute>(Id, "ranges", Attributes::Ranges::Id, credsIssuerConfig),                               //
        make_unique<SubscribeAttribute>(Id, "voltage", Attributes::Voltage::Id, credsIssuerConfig),                             //
        make_unique<SubscribeAttribute>(Id, "active-current", Attributes::ActiveCurrent::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "reactive-current", Attributes::ReactiveCurrent::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "apparent-current", Attributes::ApparentCurrent::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "active-power", Attributes::ActivePower::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "reactive-power", Attributes::ReactivePower::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "apparent-power", Attributes::ApparentPower::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "rmsvoltage", Attributes::RMSVoltage::Id, credsIssuerConfig),                       //
        make_unique<SubscribeAttribute>(Id, "rmscurrent", Attributes::RMSCurrent::Id, credsIssuerConfig),                       //
        make_unique<SubscribeAttribute>(Id, "rmspower", Attributes::RMSPower::Id, credsIssuerConfig),                           //
        make_unique<SubscribeAttribute>(Id, "frequency", Attributes::Frequency::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "harmonic-currents", Attributes::HarmonicCurrents::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "harmonic-phases", Attributes::HarmonicPhases::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "power-factor", Attributes::PowerFactor::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "neutral-current", Attributes::NeutralCurrent::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                                        //
        make_unique<ReadEvent>(Id, "measurement-period-ranges", Events::MeasurementPeriodRanges::Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                                   //
        make_unique<SubscribeEvent>(Id, "measurement-period-ranges", Events::MeasurementPeriodRanges::Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterElectricalEnergyMeasurement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::ElectricalEnergyMeasurement;

    const char * clusterName = "ElectricalEnergyMeasurement";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                       //
        make_unique<ReadAttribute>(Id, "accuracy", Attributes::Accuracy::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "cumulative-energy-imported", Attributes::CumulativeEnergyImported::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "cumulative-energy-exported", Attributes::CumulativeEnergyExported::Id,
                                   credsIssuerConfig),                                                                         //
        make_unique<ReadAttribute>(Id, "periodic-energy-imported", Attributes::PeriodicEnergyImported::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "periodic-energy-exported", Attributes::PeriodicEnergyExported::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "cumulative-energy-reset", Attributes::CumulativeEnergyReset::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                            //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),                //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                                  //
        make_unique<
            WriteAttributeAsComplex<chip::app::Clusters::ElectricalEnergyMeasurement::Structs::MeasurementAccuracyStruct::Type>>(
            Id, "accuracy", Attributes::Accuracy::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::Nullable<
            chip::app::Clusters::ElectricalEnergyMeasurement::Structs::EnergyMeasurementStruct::Type>>>(
            Id, "cumulative-energy-imported", Attributes::CumulativeEnergyImported::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::Nullable<
            chip::app::Clusters::ElectricalEnergyMeasurement::Structs::EnergyMeasurementStruct::Type>>>(
            Id, "cumulative-energy-exported", Attributes::CumulativeEnergyExported::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::Nullable<
            chip::app::Clusters::ElectricalEnergyMeasurement::Structs::EnergyMeasurementStruct::Type>>>(
            Id, "periodic-energy-imported", Attributes::PeriodicEnergyImported::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::Nullable<
            chip::app::Clusters::ElectricalEnergyMeasurement::Structs::EnergyMeasurementStruct::Type>>>(
            Id, "periodic-energy-exported", Attributes::PeriodicEnergyExported::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::Nullable<
            chip::app::Clusters::ElectricalEnergyMeasurement::Structs::CumulativeEnergyResetStruct::Type>>>(
            Id, "cumulative-energy-reset", Attributes::CumulativeEnergyReset::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),      //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                       //
        make_unique<SubscribeAttribute>(Id, "accuracy", Attributes::Accuracy::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "cumulative-energy-imported", Attributes::CumulativeEnergyImported::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "cumulative-energy-exported", Attributes::CumulativeEnergyExported::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "periodic-energy-imported", Attributes::PeriodicEnergyImported::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "periodic-energy-exported", Attributes::PeriodicEnergyExported::Id,
                                        credsIssuerConfig),                                                                       //
        make_unique<SubscribeAttribute>(Id, "cumulative-energy-reset", Attributes::CumulativeEnergyReset::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),              //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                                          //
        make_unique<ReadEvent>(Id, "cumulative-energy-measured", Events::CumulativeEnergyMeasured::Id, credsIssuerConfig),      //
        make_unique<ReadEvent>(Id, "periodic-energy-measured", Events::PeriodicEnergyMeasured::Id, credsIssuerConfig),          //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                                     //
        make_unique<SubscribeEvent>(Id, "cumulative-energy-measured", Events::CumulativeEnergyMeasured::Id, credsIssuerConfig), //
        make_unique<SubscribeEvent>(Id, "periodic-energy-measured", Events::PeriodicEnergyMeasured::Id, credsIssuerConfig),     //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterDemandResponseLoadControl(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::DemandResponseLoadControl;

    const char * clusterName = "DemandResponseLoadControl";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                                           //
        make_unique<DemandResponseLoadControlRegisterLoadControlProgramRequest>(credsIssuerConfig),   //
        make_unique<DemandResponseLoadControlUnregisterLoadControlProgramRequest>(credsIssuerConfig), //
        make_unique<DemandResponseLoadControlAddLoadControlEventRequest>(credsIssuerConfig),          //
        make_unique<DemandResponseLoadControlRemoveLoadControlEventRequest>(credsIssuerConfig),       //
        make_unique<DemandResponseLoadControlClearLoadControlEventsRequest>(credsIssuerConfig),       //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                               //
        make_unique<ReadAttribute>(Id, "load-control-programs", Attributes::LoadControlPrograms::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "number-of-load-control-programs", Attributes::NumberOfLoadControlPrograms::Id,
                                   credsIssuerConfig),                                                    //
        make_unique<ReadAttribute>(Id, "events", Attributes::Events::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "active-events", Attributes::ActiveEvents::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "number-of-events-per-program", Attributes::NumberOfEventsPerProgram::Id,
                                   credsIssuerConfig),                                                                       //
        make_unique<ReadAttribute>(Id, "number-of-transitions", Attributes::NumberOfTransitions::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "default-random-start", Attributes::DefaultRandomStart::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "default-random-duration", Attributes::DefaultRandomDuration::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),              //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                                //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<
            const chip::app::Clusters::DemandResponseLoadControl::Structs::LoadControlProgramStruct::Type>>>(
            Id, "load-control-programs", Attributes::LoadControlPrograms::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "number-of-load-control-programs", 0, UINT8_MAX,
                                             Attributes::NumberOfLoadControlPrograms::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<
            const chip::app::Clusters::DemandResponseLoadControl::Structs::LoadControlEventStruct::Type>>>(
            Id, "events", Attributes::Events::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<
            const chip::app::Clusters::DemandResponseLoadControl::Structs::LoadControlEventStruct::Type>>>(
            Id, "active-events", Attributes::ActiveEvents::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "number-of-events-per-program", 0, UINT8_MAX,
                                             Attributes::NumberOfEventsPerProgram::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "number-of-transitions", 0, UINT8_MAX, Attributes::NumberOfTransitions::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "default-random-start", 0, UINT8_MAX, Attributes::DefaultRandomStart::Id,
                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "default-random-duration", 0, UINT8_MAX, Attributes::DefaultRandomDuration::Id,
                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                              //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                               //
        make_unique<SubscribeAttribute>(Id, "load-control-programs", Attributes::LoadControlPrograms::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "number-of-load-control-programs", Attributes::NumberOfLoadControlPrograms::Id,
                                        credsIssuerConfig),                                                    //
        make_unique<SubscribeAttribute>(Id, "events", Attributes::Events::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "active-events", Attributes::ActiveEvents::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "number-of-events-per-program", Attributes::NumberOfEventsPerProgram::Id,
                                        credsIssuerConfig),                                                                       //
        make_unique<SubscribeAttribute>(Id, "number-of-transitions", Attributes::NumberOfTransitions::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "default-random-start", Attributes::DefaultRandomStart::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "default-random-duration", Attributes::DefaultRandomDuration::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),              //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig), //
        make_unique<ReadEvent>(Id, "load-control-event-status-change", Events::LoadControlEventStatusChange::Id,
                               credsIssuerConfig),          //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
        make_unique<SubscribeEvent>(Id, "load-control-event-status-change", Events::LoadControlEventStatusChange::Id,
                                    credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterMessages(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::Messages;

    const char * clusterName = "Messages";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),             //
        make_unique<MessagesPresentMessagesRequest>(credsIssuerConfig), //
        make_unique<MessagesCancelMessagesRequest>(credsIssuerConfig),  //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "messages", Attributes::Messages::Id, credsIssuerConfig),                           //
        make_unique<ReadAttribute>(Id, "active-message-ids", Attributes::ActiveMessageIDs::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<
            WriteAttributeAsComplex<chip::app::DataModel::List<const chip::app::Clusters::Messages::Structs::MessageStruct::Type>>>(
            Id, "messages", Attributes::Messages::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::ByteSpan>>>(
            Id, "active-message-ids", Attributes::ActiveMessageIDs::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "messages", Attributes::Messages::Id, credsIssuerConfig),                           //
        make_unique<SubscribeAttribute>(Id, "active-message-ids", Attributes::ActiveMessageIDs::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                         //
        make_unique<ReadEvent>(Id, "message-queued", Events::MessageQueued::Id, credsIssuerConfig),            //
        make_unique<ReadEvent>(Id, "message-presented", Events::MessagePresented::Id, credsIssuerConfig),      //
        make_unique<ReadEvent>(Id, "message-complete", Events::MessageComplete::Id, credsIssuerConfig),        //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                    //
        make_unique<SubscribeEvent>(Id, "message-queued", Events::MessageQueued::Id, credsIssuerConfig),       //
        make_unique<SubscribeEvent>(Id, "message-presented", Events::MessagePresented::Id, credsIssuerConfig), //
        make_unique<SubscribeEvent>(Id, "message-complete", Events::MessageComplete::Id, credsIssuerConfig),   //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterDeviceEnergyManagement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::DeviceEnergyManagement;

    const char * clusterName = "DeviceEnergyManagement";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                                   //
        make_unique<DeviceEnergyManagementPowerAdjustRequest>(credsIssuerConfig),             //
        make_unique<DeviceEnergyManagementCancelPowerAdjustRequest>(credsIssuerConfig),       //
        make_unique<DeviceEnergyManagementStartTimeAdjustRequest>(credsIssuerConfig),         //
        make_unique<DeviceEnergyManagementPauseRequest>(credsIssuerConfig),                   //
        make_unique<DeviceEnergyManagementResumeRequest>(credsIssuerConfig),                  //
        make_unique<DeviceEnergyManagementModifyForecastRequest>(credsIssuerConfig),          //
        make_unique<DeviceEnergyManagementRequestConstraintBasedForecast>(credsIssuerConfig), //
        make_unique<DeviceEnergyManagementCancelRequest>(credsIssuerConfig),                  //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                    //
        make_unique<ReadAttribute>(Id, "esatype", Attributes::ESAType::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "esacan-generate", Attributes::ESACanGenerate::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "esastate", Attributes::ESAState::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "abs-min-power", Attributes::AbsMinPower::Id, credsIssuerConfig),      //
        make_unique<ReadAttribute>(Id, "abs-max-power", Attributes::AbsMaxPower::Id, credsIssuerConfig),      //
        make_unique<ReadAttribute>(Id, "power-adjustment-capability", Attributes::PowerAdjustmentCapability::Id,
                                   credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "forecast", Attributes::Forecast::Id, credsIssuerConfig),                           //
        make_unique<ReadAttribute>(Id, "opt-out-state", Attributes::OptOutState::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::app::Clusters::DeviceEnergyManagement::ESATypeEnum>>(
            Id, "esatype", 0, UINT8_MAX, Attributes::ESAType::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<bool>>(Id, "esacan-generate", 0, 1, Attributes::ESACanGenerate::Id,
                                          WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::DeviceEnergyManagement::ESAStateEnum>>(
            Id, "esastate", 0, UINT8_MAX, Attributes::ESAState::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int64_t>>(Id, "abs-min-power", INT64_MIN, INT64_MAX, Attributes::AbsMinPower::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int64_t>>(Id, "abs-max-power", INT64_MIN, INT64_MAX, Attributes::AbsMaxPower::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::Nullable<
            chip::app::DataModel::List<const chip::app::Clusters::DeviceEnergyManagement::Structs::PowerAdjustStruct::Type>>>>(
            Id, "power-adjustment-capability", Attributes::PowerAdjustmentCapability::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::Nullable<chip::app::Clusters::DeviceEnergyManagement::Structs::ForecastStruct::Type>>>(
            Id, "forecast", Attributes::Forecast::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::DeviceEnergyManagement::OptOutStateEnum>>(
            Id, "opt-out-state", 0, UINT8_MAX, Attributes::OptOutState::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                   //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                    //
        make_unique<SubscribeAttribute>(Id, "esatype", Attributes::ESAType::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "esacan-generate", Attributes::ESACanGenerate::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "esastate", Attributes::ESAState::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "abs-min-power", Attributes::AbsMinPower::Id, credsIssuerConfig),      //
        make_unique<SubscribeAttribute>(Id, "abs-max-power", Attributes::AbsMaxPower::Id, credsIssuerConfig),      //
        make_unique<SubscribeAttribute>(Id, "power-adjustment-capability", Attributes::PowerAdjustmentCapability::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "forecast", Attributes::Forecast::Id, credsIssuerConfig),                           //
        make_unique<SubscribeAttribute>(Id, "opt-out-state", Attributes::OptOutState::Id, credsIssuerConfig),                   //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                          //
        make_unique<ReadEvent>(Id, "power-adjust-start", Events::PowerAdjustStart::Id, credsIssuerConfig),      //
        make_unique<ReadEvent>(Id, "power-adjust-end", Events::PowerAdjustEnd::Id, credsIssuerConfig),          //
        make_unique<ReadEvent>(Id, "paused", Events::Paused::Id, credsIssuerConfig),                            //
        make_unique<ReadEvent>(Id, "resumed", Events::Resumed::Id, credsIssuerConfig),                          //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                     //
        make_unique<SubscribeEvent>(Id, "power-adjust-start", Events::PowerAdjustStart::Id, credsIssuerConfig), //
        make_unique<SubscribeEvent>(Id, "power-adjust-end", Events::PowerAdjustEnd::Id, credsIssuerConfig),     //
        make_unique<SubscribeEvent>(Id, "paused", Events::Paused::Id, credsIssuerConfig),                       //
        make_unique<SubscribeEvent>(Id, "resumed", Events::Resumed::Id, credsIssuerConfig),                     //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterEnergyEvse(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::EnergyEvse;

    const char * clusterName = "EnergyEvse";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),          //
        make_unique<EnergyEvseDisable>(credsIssuerConfig),           //
        make_unique<EnergyEvseEnableCharging>(credsIssuerConfig),    //
        make_unique<EnergyEvseEnableDischarging>(credsIssuerConfig), //
        make_unique<EnergyEvseStartDiagnostics>(credsIssuerConfig),  //
        make_unique<EnergyEvseSetTargets>(credsIssuerConfig),        //
        make_unique<EnergyEvseGetTargets>(credsIssuerConfig),        //
        make_unique<EnergyEvseClearTargets>(credsIssuerConfig),      //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                       //
        make_unique<ReadAttribute>(Id, "state", Attributes::State::Id, credsIssuerConfig),                                       //
        make_unique<ReadAttribute>(Id, "supply-state", Attributes::SupplyState::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "fault-state", Attributes::FaultState::Id, credsIssuerConfig),                            //
        make_unique<ReadAttribute>(Id, "charging-enabled-until", Attributes::ChargingEnabledUntil::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "discharging-enabled-until", Attributes::DischargingEnabledUntil::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "circuit-capacity", Attributes::CircuitCapacity::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "minimum-charge-current", Attributes::MinimumChargeCurrent::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "maximum-charge-current", Attributes::MaximumChargeCurrent::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "maximum-discharge-current", Attributes::MaximumDischargeCurrent::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "user-maximum-charge-current", Attributes::UserMaximumChargeCurrent::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "randomization-delay-window", Attributes::RandomizationDelayWindow::Id,
                                   credsIssuerConfig),                                                                      //
        make_unique<ReadAttribute>(Id, "next-charge-start-time", Attributes::NextChargeStartTime::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "next-charge-target-time", Attributes::NextChargeTargetTime::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "next-charge-required-energy", Attributes::NextChargeRequiredEnergy::Id,
                                   credsIssuerConfig),                                                                           //
        make_unique<ReadAttribute>(Id, "next-charge-target-so-c", Attributes::NextChargeTargetSoC::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "approximate-evefficiency", Attributes::ApproximateEVEfficiency::Id, credsIssuerConfig),  //
        make_unique<ReadAttribute>(Id, "state-of-charge", Attributes::StateOfCharge::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "battery-capacity", Attributes::BatteryCapacity::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "vehicle-id", Attributes::VehicleID::Id, credsIssuerConfig),                              //
        make_unique<ReadAttribute>(Id, "session-id", Attributes::SessionID::Id, credsIssuerConfig),                              //
        make_unique<ReadAttribute>(Id, "session-duration", Attributes::SessionDuration::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "session-energy-charged", Attributes::SessionEnergyCharged::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "session-energy-discharged", Attributes::SessionEnergyDischarged::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                              //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                            //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),                  //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                                    //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::app::Clusters::EnergyEvse::StateEnum>>>(
            Id, "state", 0, UINT8_MAX, Attributes::State::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::EnergyEvse::SupplyStateEnum>>(
            Id, "supply-state", 0, UINT8_MAX, Attributes::SupplyState::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::EnergyEvse::FaultStateEnum>>(
            Id, "fault-state", 0, UINT8_MAX, Attributes::FaultState::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(Id, "charging-enabled-until", 0, UINT32_MAX,
                                                                              Attributes::ChargingEnabledUntil::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(Id, "discharging-enabled-until", 0, UINT32_MAX,
                                                                              Attributes::DischargingEnabledUntil::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int64_t>>(Id, "circuit-capacity", INT64_MIN, INT64_MAX, Attributes::CircuitCapacity::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int64_t>>(Id, "minimum-charge-current", INT64_MIN, INT64_MAX,
                                             Attributes::MinimumChargeCurrent::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int64_t>>(Id, "maximum-charge-current", INT64_MIN, INT64_MAX,
                                             Attributes::MaximumChargeCurrent::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int64_t>>(Id, "maximum-discharge-current", INT64_MIN, INT64_MAX,
                                             Attributes::MaximumDischargeCurrent::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int64_t>>(Id, "user-maximum-charge-current", INT64_MIN, INT64_MAX,
                                             Attributes::UserMaximumChargeCurrent::Id, WriteCommandType::kWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "randomization-delay-window", 0, UINT32_MAX,
                                              Attributes::RandomizationDelayWindow::Id, WriteCommandType::kWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(Id, "next-charge-start-time", 0, UINT32_MAX,
                                                                              Attributes::NextChargeStartTime::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(Id, "next-charge-target-time", 0, UINT32_MAX,
                                                                              Attributes::NextChargeTargetTime::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int64_t>>>(Id, "next-charge-required-energy", INT64_MIN,
                                                                             INT64_MAX, Attributes::NextChargeRequiredEnergy::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::Percent>>>(
            Id, "next-charge-target-so-c", 0, UINT8_MAX, Attributes::NextChargeTargetSoC::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint16_t>>>(Id, "approximate-evefficiency", 0, UINT16_MAX,
                                                                              Attributes::ApproximateEVEfficiency::Id,
                                                                              WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::Percent>>>(
            Id, "state-of-charge", 0, UINT8_MAX, Attributes::StateOfCharge::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int64_t>>>(Id, "battery-capacity", INT64_MIN, INT64_MAX,
                                                                             Attributes::BatteryCapacity::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::CharSpan>>>(
            Id, "vehicle-id", Attributes::VehicleID::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(
            Id, "session-id", 0, UINT32_MAX, Attributes::SessionID::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(Id, "session-duration", 0, UINT32_MAX,
                                                                              Attributes::SessionDuration::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int64_t>>>(Id, "session-energy-charged", INT64_MIN, INT64_MAX,
                                                                             Attributes::SessionEnergyCharged::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int64_t>>>(Id, "session-energy-discharged", INT64_MIN, INT64_MAX,
                                                                             Attributes::SessionEnergyDischarged::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "state", Attributes::State::Id, credsIssuerConfig),                                 //
        make_unique<SubscribeAttribute>(Id, "supply-state", Attributes::SupplyState::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "fault-state", Attributes::FaultState::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "charging-enabled-until", Attributes::ChargingEnabledUntil::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "discharging-enabled-until", Attributes::DischargingEnabledUntil::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "circuit-capacity", Attributes::CircuitCapacity::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "minimum-charge-current", Attributes::MinimumChargeCurrent::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "maximum-charge-current", Attributes::MaximumChargeCurrent::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "maximum-discharge-current", Attributes::MaximumDischargeCurrent::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "user-maximum-charge-current", Attributes::UserMaximumChargeCurrent::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "randomization-delay-window", Attributes::RandomizationDelayWindow::Id,
                                        credsIssuerConfig),                                                                      //
        make_unique<SubscribeAttribute>(Id, "next-charge-start-time", Attributes::NextChargeStartTime::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "next-charge-target-time", Attributes::NextChargeTargetTime::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "next-charge-required-energy", Attributes::NextChargeRequiredEnergy::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "next-charge-target-so-c", Attributes::NextChargeTargetSoC::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "approximate-evefficiency", Attributes::ApproximateEVEfficiency::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "state-of-charge", Attributes::StateOfCharge::Id, credsIssuerConfig),               //
        make_unique<SubscribeAttribute>(Id, "battery-capacity", Attributes::BatteryCapacity::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "vehicle-id", Attributes::VehicleID::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "session-id", Attributes::SessionID::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "session-duration", Attributes::SessionDuration::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "session-energy-charged", Attributes::SessionEnergyCharged::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "session-energy-discharged", Attributes::SessionEnergyDischarged::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                                    //
        make_unique<ReadEvent>(Id, "evconnected", Events::EVConnected::Id, credsIssuerConfig),                            //
        make_unique<ReadEvent>(Id, "evnot-detected", Events::EVNotDetected::Id, credsIssuerConfig),                       //
        make_unique<ReadEvent>(Id, "energy-transfer-started", Events::EnergyTransferStarted::Id, credsIssuerConfig),      //
        make_unique<ReadEvent>(Id, "energy-transfer-stopped", Events::EnergyTransferStopped::Id, credsIssuerConfig),      //
        make_unique<ReadEvent>(Id, "fault", Events::Fault::Id, credsIssuerConfig),                                        //
        make_unique<ReadEvent>(Id, "rfid", Events::Rfid::Id, credsIssuerConfig),                                          //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                               //
        make_unique<SubscribeEvent>(Id, "evconnected", Events::EVConnected::Id, credsIssuerConfig),                       //
        make_unique<SubscribeEvent>(Id, "evnot-detected", Events::EVNotDetected::Id, credsIssuerConfig),                  //
        make_unique<SubscribeEvent>(Id, "energy-transfer-started", Events::EnergyTransferStarted::Id, credsIssuerConfig), //
        make_unique<SubscribeEvent>(Id, "energy-transfer-stopped", Events::EnergyTransferStopped::Id, credsIssuerConfig), //
        make_unique<SubscribeEvent>(Id, "fault", Events::Fault::Id, credsIssuerConfig),                                   //
        make_unique<SubscribeEvent>(Id, "rfid", Events::Rfid::Id, credsIssuerConfig),                                     //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterEnergyPreference(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::EnergyPreference;

    const char * clusterName = "EnergyPreference";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "energy-balances", Attributes::EnergyBalances::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "current-energy-balance", Attributes::CurrentEnergyBalance::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "energy-priorities", Attributes::EnergyPriorities::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "low-power-mode-sensitivities", Attributes::LowPowerModeSensitivities::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "current-low-power-mode-sensitivity", Attributes::CurrentLowPowerModeSensitivity::Id,
                                   credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::EnergyPreference::Structs::BalanceStruct::Type>>>(
            Id, "energy-balances", Attributes::EnergyBalances::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "current-energy-balance", 0, UINT8_MAX, Attributes::CurrentEnergyBalance::Id,
                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<
            WriteAttributeAsComplex<chip::app::DataModel::List<const chip::app::Clusters::EnergyPreference::EnergyPriorityEnum>>>(
            Id, "energy-priorities", Attributes::EnergyPriorities::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::EnergyPreference::Structs::BalanceStruct::Type>>>(
            Id, "low-power-mode-sensitivities", Attributes::LowPowerModeSensitivities::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "current-low-power-mode-sensitivity", 0, UINT8_MAX,
                                             Attributes::CurrentLowPowerModeSensitivity::Id, WriteCommandType::kWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "energy-balances", Attributes::EnergyBalances::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "current-energy-balance", Attributes::CurrentEnergyBalance::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "energy-priorities", Attributes::EnergyPriorities::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "low-power-mode-sensitivities", Attributes::LowPowerModeSensitivities::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "current-low-power-mode-sensitivity", Attributes::CurrentLowPowerModeSensitivity::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterPowerTopology(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::PowerTopology;

    const char * clusterName = "PowerTopology";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "available-endpoints", Attributes::AvailableEndpoints::Id, credsIssuerConfig),      //
        make_unique<ReadAttribute>(Id, "active-endpoints", Attributes::ActiveEndpoints::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EndpointId>>>(
            Id, "available-endpoints", Attributes::AvailableEndpoints::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EndpointId>>>(
            Id, "active-endpoints", Attributes::ActiveEndpoints::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "available-endpoints", Attributes::AvailableEndpoints::Id, credsIssuerConfig),      //
        make_unique<SubscribeAttribute>(Id, "active-endpoints", Attributes::ActiveEndpoints::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterEnergyEvseMode(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::EnergyEvseMode;

    const char * clusterName = "EnergyEvseMode";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),         //
        make_unique<EnergyEvseModeChangeToMode>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "supported-modes", Attributes::SupportedModes::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "current-mode", Attributes::CurrentMode::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "start-up-mode", Attributes::StartUpMode::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "on-mode", Attributes::OnMode::Id, credsIssuerConfig),                              //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::EnergyEvseMode::Structs::ModeOptionStruct::Type>>>(
            Id, "supported-modes", Attributes::SupportedModes::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "current-mode", 0, UINT8_MAX, Attributes::CurrentMode::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(
            Id, "start-up-mode", 0, UINT8_MAX, Attributes::StartUpMode::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(Id, "on-mode", 0, UINT8_MAX, Attributes::OnMode::Id,
                                                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "supported-modes", Attributes::SupportedModes::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "current-mode", Attributes::CurrentMode::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "start-up-mode", Attributes::StartUpMode::Id, credsIssuerConfig),                   //
        make_unique<SubscribeAttribute>(Id, "on-mode", Attributes::OnMode::Id, credsIssuerConfig),                              //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterDeviceEnergyManagementMode(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::DeviceEnergyManagementMode;

    const char * clusterName = "DeviceEnergyManagementMode";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                     //
        make_unique<DeviceEnergyManagementModeChangeToMode>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "supported-modes", Attributes::SupportedModes::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "current-mode", Attributes::CurrentMode::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "start-up-mode", Attributes::StartUpMode::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "on-mode", Attributes::OnMode::Id, credsIssuerConfig),                              //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::DeviceEnergyManagementMode::Structs::ModeOptionStruct::Type>>>(
            Id, "supported-modes", Attributes::SupportedModes::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "current-mode", 0, UINT8_MAX, Attributes::CurrentMode::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(
            Id, "start-up-mode", 0, UINT8_MAX, Attributes::StartUpMode::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(Id, "on-mode", 0, UINT8_MAX, Attributes::OnMode::Id,
                                                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "supported-modes", Attributes::SupportedModes::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "current-mode", Attributes::CurrentMode::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "start-up-mode", Attributes::StartUpMode::Id, credsIssuerConfig),                   //
        make_unique<SubscribeAttribute>(Id, "on-mode", Attributes::OnMode::Id, credsIssuerConfig),                              //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterDoorLock(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::DoorLock;

    const char * clusterName = "DoorLock";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),             //
        make_unique<DoorLockLockDoor>(credsIssuerConfig),               //
        make_unique<DoorLockUnlockDoor>(credsIssuerConfig),             //
        make_unique<DoorLockUnlockWithTimeout>(credsIssuerConfig),      //
        make_unique<DoorLockSetWeekDaySchedule>(credsIssuerConfig),     //
        make_unique<DoorLockGetWeekDaySchedule>(credsIssuerConfig),     //
        make_unique<DoorLockClearWeekDaySchedule>(credsIssuerConfig),   //
        make_unique<DoorLockSetYearDaySchedule>(credsIssuerConfig),     //
        make_unique<DoorLockGetYearDaySchedule>(credsIssuerConfig),     //
        make_unique<DoorLockClearYearDaySchedule>(credsIssuerConfig),   //
        make_unique<DoorLockSetHolidaySchedule>(credsIssuerConfig),     //
        make_unique<DoorLockGetHolidaySchedule>(credsIssuerConfig),     //
        make_unique<DoorLockClearHolidaySchedule>(credsIssuerConfig),   //
        make_unique<DoorLockSetUser>(credsIssuerConfig),                //
        make_unique<DoorLockGetUser>(credsIssuerConfig),                //
        make_unique<DoorLockClearUser>(credsIssuerConfig),              //
        make_unique<DoorLockSetCredential>(credsIssuerConfig),          //
        make_unique<DoorLockGetCredentialStatus>(credsIssuerConfig),    //
        make_unique<DoorLockClearCredential>(credsIssuerConfig),        //
        make_unique<DoorLockUnboltDoor>(credsIssuerConfig),             //
        make_unique<DoorLockSetAliroReaderConfig>(credsIssuerConfig),   //
        make_unique<DoorLockClearAliroReaderConfig>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                         //
        make_unique<ReadAttribute>(Id, "lock-state", Attributes::LockState::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "lock-type", Attributes::LockType::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "actuator-enabled", Attributes::ActuatorEnabled::Id, credsIssuerConfig),    //
        make_unique<ReadAttribute>(Id, "door-state", Attributes::DoorState::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "door-open-events", Attributes::DoorOpenEvents::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "door-closed-events", Attributes::DoorClosedEvents::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "open-period", Attributes::OpenPeriod::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "number-of-total-users-supported", Attributes::NumberOfTotalUsersSupported::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "number-of-pinusers-supported", Attributes::NumberOfPINUsersSupported::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "number-of-rfidusers-supported", Attributes::NumberOfRFIDUsersSupported::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "number-of-week-day-schedules-supported-per-user",
                                   Attributes::NumberOfWeekDaySchedulesSupportedPerUser::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "number-of-year-day-schedules-supported-per-user",
                                   Attributes::NumberOfYearDaySchedulesSupportedPerUser::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "number-of-holiday-schedules-supported", Attributes::NumberOfHolidaySchedulesSupported::Id,
                                   credsIssuerConfig),                                                                         //
        make_unique<ReadAttribute>(Id, "max-pincode-length", Attributes::MaxPINCodeLength::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "min-pincode-length", Attributes::MinPINCodeLength::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "max-rfidcode-length", Attributes::MaxRFIDCodeLength::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "min-rfidcode-length", Attributes::MinRFIDCodeLength::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "credential-rules-support", Attributes::CredentialRulesSupport::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "number-of-credentials-supported-per-user",
                                   Attributes::NumberOfCredentialsSupportedPerUser::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "language", Attributes::Language::Id, credsIssuerConfig),                                 //
        make_unique<ReadAttribute>(Id, "ledsettings", Attributes::LEDSettings::Id, credsIssuerConfig),                           //
        make_unique<ReadAttribute>(Id, "auto-relock-time", Attributes::AutoRelockTime::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "sound-volume", Attributes::SoundVolume::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "operating-mode", Attributes::OperatingMode::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "supported-operating-modes", Attributes::SupportedOperatingModes::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "default-configuration-register", Attributes::DefaultConfigurationRegister::Id,
                                   credsIssuerConfig),                                                                            //
        make_unique<ReadAttribute>(Id, "enable-local-programming", Attributes::EnableLocalProgramming::Id, credsIssuerConfig),    //
        make_unique<ReadAttribute>(Id, "enable-one-touch-locking", Attributes::EnableOneTouchLocking::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "enable-inside-status-led", Attributes::EnableInsideStatusLED::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "enable-privacy-mode-button", Attributes::EnablePrivacyModeButton::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "local-programming-features", Attributes::LocalProgrammingFeatures::Id,
                                   credsIssuerConfig),                                                                    //
        make_unique<ReadAttribute>(Id, "wrong-code-entry-limit", Attributes::WrongCodeEntryLimit::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "user-code-temporary-disable-time", Attributes::UserCodeTemporaryDisableTime::Id,
                                   credsIssuerConfig),                                                                //
        make_unique<ReadAttribute>(Id, "send-pinover-the-air", Attributes::SendPINOverTheAir::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "require-pinfor-remote-operation", Attributes::RequirePINforRemoteOperation::Id,
                                   credsIssuerConfig),                                                                   //
        make_unique<ReadAttribute>(Id, "expiring-user-timeout", Attributes::ExpiringUserTimeout::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "aliro-reader-verification-key", Attributes::AliroReaderVerificationKey::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "aliro-reader-group-identifier", Attributes::AliroReaderGroupIdentifier::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "aliro-reader-group-sub-identifier", Attributes::AliroReaderGroupSubIdentifier::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "aliro-expedited-transaction-supported-protocol-versions",
                                   Attributes::AliroExpeditedTransactionSupportedProtocolVersions::Id, credsIssuerConfig),      //
        make_unique<ReadAttribute>(Id, "aliro-group-resolving-key", Attributes::AliroGroupResolvingKey::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "aliro-supported-bleuwbprotocol-versions",
                                   Attributes::AliroSupportedBLEUWBProtocolVersions::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "aliro-bleadvertising-version", Attributes::AliroBLEAdvertisingVersion::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "number-of-aliro-credential-issuer-keys-supported",
                                   Attributes::NumberOfAliroCredentialIssuerKeysSupported::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "number-of-aliro-endpoint-keys-supported",
                                   Attributes::NumberOfAliroEndpointKeysSupported::Id, credsIssuerConfig),                 //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlLockState>>>(
            Id, "lock-state", 0, UINT8_MAX, Attributes::LockState::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::DoorLock::DlLockType>>(
            Id, "lock-type", 0, UINT8_MAX, Attributes::LockType::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<bool>>(Id, "actuator-enabled", 0, 1, Attributes::ActuatorEnabled::Id,
                                          WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DoorStateEnum>>>(
            Id, "door-state", 0, UINT8_MAX, Attributes::DoorState::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "door-open-events", 0, UINT32_MAX, Attributes::DoorOpenEvents::Id,
                                              WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "door-closed-events", 0, UINT32_MAX, Attributes::DoorClosedEvents::Id,
                                              WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "open-period", 0, UINT16_MAX, Attributes::OpenPeriod::Id,
                                              WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "number-of-total-users-supported", 0, UINT16_MAX,
                                              Attributes::NumberOfTotalUsersSupported::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "number-of-pinusers-supported", 0, UINT16_MAX,
                                              Attributes::NumberOfPINUsersSupported::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "number-of-rfidusers-supported", 0, UINT16_MAX,
                                              Attributes::NumberOfRFIDUsersSupported::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "number-of-week-day-schedules-supported-per-user", 0, UINT8_MAX,
                                             Attributes::NumberOfWeekDaySchedulesSupportedPerUser::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "number-of-year-day-schedules-supported-per-user", 0, UINT8_MAX,
                                             Attributes::NumberOfYearDaySchedulesSupportedPerUser::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "number-of-holiday-schedules-supported", 0, UINT8_MAX,
                                             Attributes::NumberOfHolidaySchedulesSupported::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "max-pincode-length", 0, UINT8_MAX, Attributes::MaxPINCodeLength::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "min-pincode-length", 0, UINT8_MAX, Attributes::MinPINCodeLength::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "max-rfidcode-length", 0, UINT8_MAX, Attributes::MaxRFIDCodeLength::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "min-rfidcode-length", 0, UINT8_MAX, Attributes::MinRFIDCodeLength::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::DoorLock::DlCredentialRuleMask>>>(
            Id, "credential-rules-support", 0, UINT8_MAX, Attributes::CredentialRulesSupport::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "number-of-credentials-supported-per-user", 0, UINT8_MAX,
                                             Attributes::NumberOfCredentialsSupportedPerUser::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "language", Attributes::Language::Id, WriteCommandType::kWrite,
                                                    credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "ledsettings", 0, UINT8_MAX, Attributes::LEDSettings::Id, WriteCommandType::kWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "auto-relock-time", 0, UINT32_MAX, Attributes::AutoRelockTime::Id,
                                              WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "sound-volume", 0, UINT8_MAX, Attributes::SoundVolume::Id,
                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::DoorLock::OperatingModeEnum>>(
            Id, "operating-mode", 0, UINT8_MAX, Attributes::OperatingMode::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::DoorLock::DlSupportedOperatingModes>>>(
            Id, "supported-operating-modes", 0, UINT16_MAX, Attributes::SupportedOperatingModes::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::DoorLock::DlDefaultConfigurationRegister>>>(
            Id, "default-configuration-register", 0, UINT16_MAX, Attributes::DefaultConfigurationRegister::Id,
            WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<bool>>(Id, "enable-local-programming", 0, 1, Attributes::EnableLocalProgramming::Id,
                                          WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<bool>>(Id, "enable-one-touch-locking", 0, 1, Attributes::EnableOneTouchLocking::Id,
                                          WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<bool>>(Id, "enable-inside-status-led", 0, 1, Attributes::EnableInsideStatusLED::Id,
                                          WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<bool>>(Id, "enable-privacy-mode-button", 0, 1, Attributes::EnablePrivacyModeButton::Id,
                                          WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::DoorLock::DlLocalProgrammingFeatures>>>(
            Id, "local-programming-features", 0, UINT8_MAX, Attributes::LocalProgrammingFeatures::Id, WriteCommandType::kWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "wrong-code-entry-limit", 0, UINT8_MAX, Attributes::WrongCodeEntryLimit::Id,
                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "user-code-temporary-disable-time", 0, UINT8_MAX,
                                             Attributes::UserCodeTemporaryDisableTime::Id, WriteCommandType::kWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<bool>>(Id, "send-pinover-the-air", 0, 1, Attributes::SendPINOverTheAir::Id,
                                          WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<bool>>(Id, "require-pinfor-remote-operation", 0, 1, Attributes::RequirePINforRemoteOperation::Id,
                                          WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "expiring-user-timeout", 0, UINT16_MAX, Attributes::ExpiringUserTimeout::Id,
                                              WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::ByteSpan>>>(
            Id, "aliro-reader-verification-key", Attributes::AliroReaderVerificationKey::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::ByteSpan>>>(
            Id, "aliro-reader-group-identifier", Attributes::AliroReaderGroupIdentifier::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::ByteSpan>>(Id, "aliro-reader-group-sub-identifier",
                                                    Attributes::AliroReaderGroupSubIdentifier::Id, WriteCommandType::kForceWrite,
                                                    credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::ByteSpan>>>(
            Id, "aliro-expedited-transaction-supported-protocol-versions",
            Attributes::AliroExpeditedTransactionSupportedProtocolVersions::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::ByteSpan>>>(
            Id, "aliro-group-resolving-key", Attributes::AliroGroupResolvingKey::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::ByteSpan>>>(
            Id, "aliro-supported-bleuwbprotocol-versions", Attributes::AliroSupportedBLEUWBProtocolVersions::Id,
            WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "aliro-bleadvertising-version", 0, UINT8_MAX,
                                             Attributes::AliroBLEAdvertisingVersion::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "number-of-aliro-credential-issuer-keys-supported", 0, UINT16_MAX,
                                              Attributes::NumberOfAliroCredentialIssuerKeysSupported::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "number-of-aliro-endpoint-keys-supported", 0, UINT16_MAX,
                                              Attributes::NumberOfAliroEndpointKeysSupported::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                         //
        make_unique<SubscribeAttribute>(Id, "lock-state", Attributes::LockState::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "lock-type", Attributes::LockType::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "actuator-enabled", Attributes::ActuatorEnabled::Id, credsIssuerConfig),    //
        make_unique<SubscribeAttribute>(Id, "door-state", Attributes::DoorState::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "door-open-events", Attributes::DoorOpenEvents::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "door-closed-events", Attributes::DoorClosedEvents::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "open-period", Attributes::OpenPeriod::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "number-of-total-users-supported", Attributes::NumberOfTotalUsersSupported::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "number-of-pinusers-supported", Attributes::NumberOfPINUsersSupported::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "number-of-rfidusers-supported", Attributes::NumberOfRFIDUsersSupported::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "number-of-week-day-schedules-supported-per-user",
                                        Attributes::NumberOfWeekDaySchedulesSupportedPerUser::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "number-of-year-day-schedules-supported-per-user",
                                        Attributes::NumberOfYearDaySchedulesSupportedPerUser::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "number-of-holiday-schedules-supported",
                                        Attributes::NumberOfHolidaySchedulesSupported::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "max-pincode-length", Attributes::MaxPINCodeLength::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "min-pincode-length", Attributes::MinPINCodeLength::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "max-rfidcode-length", Attributes::MaxRFIDCodeLength::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "min-rfidcode-length", Attributes::MinRFIDCodeLength::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "credential-rules-support", Attributes::CredentialRulesSupport::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "number-of-credentials-supported-per-user",
                                        Attributes::NumberOfCredentialsSupportedPerUser::Id, credsIssuerConfig),    //
        make_unique<SubscribeAttribute>(Id, "language", Attributes::Language::Id, credsIssuerConfig),               //
        make_unique<SubscribeAttribute>(Id, "ledsettings", Attributes::LEDSettings::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "auto-relock-time", Attributes::AutoRelockTime::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "sound-volume", Attributes::SoundVolume::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "operating-mode", Attributes::OperatingMode::Id, credsIssuerConfig),    //
        make_unique<SubscribeAttribute>(Id, "supported-operating-modes", Attributes::SupportedOperatingModes::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "default-configuration-register", Attributes::DefaultConfigurationRegister::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "enable-local-programming", Attributes::EnableLocalProgramming::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "enable-one-touch-locking", Attributes::EnableOneTouchLocking::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "enable-inside-status-led", Attributes::EnableInsideStatusLED::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "enable-privacy-mode-button", Attributes::EnablePrivacyModeButton::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "local-programming-features", Attributes::LocalProgrammingFeatures::Id,
                                        credsIssuerConfig),                                                                    //
        make_unique<SubscribeAttribute>(Id, "wrong-code-entry-limit", Attributes::WrongCodeEntryLimit::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "user-code-temporary-disable-time", Attributes::UserCodeTemporaryDisableTime::Id,
                                        credsIssuerConfig),                                                                //
        make_unique<SubscribeAttribute>(Id, "send-pinover-the-air", Attributes::SendPINOverTheAir::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "require-pinfor-remote-operation", Attributes::RequirePINforRemoteOperation::Id,
                                        credsIssuerConfig),                                                                   //
        make_unique<SubscribeAttribute>(Id, "expiring-user-timeout", Attributes::ExpiringUserTimeout::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "aliro-reader-verification-key", Attributes::AliroReaderVerificationKey::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "aliro-reader-group-identifier", Attributes::AliroReaderGroupIdentifier::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "aliro-reader-group-sub-identifier", Attributes::AliroReaderGroupSubIdentifier::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "aliro-expedited-transaction-supported-protocol-versions",
                                        Attributes::AliroExpeditedTransactionSupportedProtocolVersions::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "aliro-group-resolving-key", Attributes::AliroGroupResolvingKey::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "aliro-supported-bleuwbprotocol-versions",
                                        Attributes::AliroSupportedBLEUWBProtocolVersions::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "aliro-bleadvertising-version", Attributes::AliroBLEAdvertisingVersion::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "number-of-aliro-credential-issuer-keys-supported",
                                        Attributes::NumberOfAliroCredentialIssuerKeysSupported::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "number-of-aliro-endpoint-keys-supported",
                                        Attributes::NumberOfAliroEndpointKeysSupported::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                              //
        make_unique<ReadEvent>(Id, "door-lock-alarm", Events::DoorLockAlarm::Id, credsIssuerConfig),                //
        make_unique<ReadEvent>(Id, "door-state-change", Events::DoorStateChange::Id, credsIssuerConfig),            //
        make_unique<ReadEvent>(Id, "lock-operation", Events::LockOperation::Id, credsIssuerConfig),                 //
        make_unique<ReadEvent>(Id, "lock-operation-error", Events::LockOperationError::Id, credsIssuerConfig),      //
        make_unique<ReadEvent>(Id, "lock-user-change", Events::LockUserChange::Id, credsIssuerConfig),              //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                         //
        make_unique<SubscribeEvent>(Id, "door-lock-alarm", Events::DoorLockAlarm::Id, credsIssuerConfig),           //
        make_unique<SubscribeEvent>(Id, "door-state-change", Events::DoorStateChange::Id, credsIssuerConfig),       //
        make_unique<SubscribeEvent>(Id, "lock-operation", Events::LockOperation::Id, credsIssuerConfig),            //
        make_unique<SubscribeEvent>(Id, "lock-operation-error", Events::LockOperationError::Id, credsIssuerConfig), //
        make_unique<SubscribeEvent>(Id, "lock-user-change", Events::LockUserChange::Id, credsIssuerConfig),         //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterWindowCovering(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::WindowCovering;

    const char * clusterName = "WindowCovering";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),               //
        make_unique<WindowCoveringUpOrOpen>(credsIssuerConfig),           //
        make_unique<WindowCoveringDownOrClose>(credsIssuerConfig),        //
        make_unique<WindowCoveringStopMotion>(credsIssuerConfig),         //
        make_unique<WindowCoveringGoToLiftValue>(credsIssuerConfig),      //
        make_unique<WindowCoveringGoToLiftPercentage>(credsIssuerConfig), //
        make_unique<WindowCoveringGoToTiltValue>(credsIssuerConfig),      //
        make_unique<WindowCoveringGoToTiltPercentage>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                        //
        make_unique<ReadAttribute>(Id, "type", Attributes::Type::Id, credsIssuerConfig),                                          //
        make_unique<ReadAttribute>(Id, "physical-closed-limit-lift", Attributes::PhysicalClosedLimitLift::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "physical-closed-limit-tilt", Attributes::PhysicalClosedLimitTilt::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "current-position-lift", Attributes::CurrentPositionLift::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "current-position-tilt", Attributes::CurrentPositionTilt::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "number-of-actuations-lift", Attributes::NumberOfActuationsLift::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "number-of-actuations-tilt", Attributes::NumberOfActuationsTilt::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "config-status", Attributes::ConfigStatus::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "current-position-lift-percentage", Attributes::CurrentPositionLiftPercentage::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "current-position-tilt-percentage", Attributes::CurrentPositionTiltPercentage::Id,
                                   credsIssuerConfig),                                                              //
        make_unique<ReadAttribute>(Id, "operational-status", Attributes::OperationalStatus::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "target-position-lift-percent100ths", Attributes::TargetPositionLiftPercent100ths::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "target-position-tilt-percent100ths", Attributes::TargetPositionTiltPercent100ths::Id,
                                   credsIssuerConfig),                                                         //
        make_unique<ReadAttribute>(Id, "end-product-type", Attributes::EndProductType::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "current-position-lift-percent100ths", Attributes::CurrentPositionLiftPercent100ths::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "current-position-tilt-percent100ths", Attributes::CurrentPositionTiltPercent100ths::Id,
                                   credsIssuerConfig),                                                                          //
        make_unique<ReadAttribute>(Id, "installed-open-limit-lift", Attributes::InstalledOpenLimitLift::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "installed-closed-limit-lift", Attributes::InstalledClosedLimitLift::Id,
                                   credsIssuerConfig),                                                                          //
        make_unique<ReadAttribute>(Id, "installed-open-limit-tilt", Attributes::InstalledOpenLimitTilt::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "installed-closed-limit-tilt", Attributes::InstalledClosedLimitTilt::Id,
                                   credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "mode", Attributes::Mode::Id, credsIssuerConfig),                                   //
        make_unique<ReadAttribute>(Id, "safety-status", Attributes::SafetyStatus::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::app::Clusters::WindowCovering::Type>>(Id, "type", 0, UINT8_MAX, Attributes::Type::Id,
                                                                               WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "physical-closed-limit-lift", 0, UINT16_MAX,
                                              Attributes::PhysicalClosedLimitLift::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "physical-closed-limit-tilt", 0, UINT16_MAX,
                                              Attributes::PhysicalClosedLimitTilt::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint16_t>>>(Id, "current-position-lift", 0, UINT16_MAX,
                                                                              Attributes::CurrentPositionLift::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint16_t>>>(Id, "current-position-tilt", 0, UINT16_MAX,
                                                                              Attributes::CurrentPositionTilt::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "number-of-actuations-lift", 0, UINT16_MAX,
                                              Attributes::NumberOfActuationsLift::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "number-of-actuations-tilt", 0, UINT16_MAX,
                                              Attributes::NumberOfActuationsTilt::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::WindowCovering::ConfigStatus>>>(
            Id, "config-status", 0, UINT8_MAX, Attributes::ConfigStatus::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::Percent>>>(
            Id, "current-position-lift-percentage", 0, UINT8_MAX, Attributes::CurrentPositionLiftPercentage::Id,
            WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::Percent>>>(
            Id, "current-position-tilt-percentage", 0, UINT8_MAX, Attributes::CurrentPositionTiltPercentage::Id,
            WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::WindowCovering::OperationalStatus>>>(
            Id, "operational-status", 0, UINT8_MAX, Attributes::OperationalStatus::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::Percent100ths>>>(
            Id, "target-position-lift-percent100ths", 0, UINT16_MAX, Attributes::TargetPositionLiftPercent100ths::Id,
            WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::Percent100ths>>>(
            Id, "target-position-tilt-percent100ths", 0, UINT16_MAX, Attributes::TargetPositionTiltPercent100ths::Id,
            WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::WindowCovering::EndProductType>>(
            Id, "end-product-type", 0, UINT8_MAX, Attributes::EndProductType::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::Percent100ths>>>(
            Id, "current-position-lift-percent100ths", 0, UINT16_MAX, Attributes::CurrentPositionLiftPercent100ths::Id,
            WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::Percent100ths>>>(
            Id, "current-position-tilt-percent100ths", 0, UINT16_MAX, Attributes::CurrentPositionTiltPercent100ths::Id,
            WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "installed-open-limit-lift", 0, UINT16_MAX,
                                              Attributes::InstalledOpenLimitLift::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "installed-closed-limit-lift", 0, UINT16_MAX,
                                              Attributes::InstalledClosedLimitLift::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "installed-open-limit-tilt", 0, UINT16_MAX,
                                              Attributes::InstalledOpenLimitTilt::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "installed-closed-limit-tilt", 0, UINT16_MAX,
                                              Attributes::InstalledClosedLimitTilt::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::WindowCovering::Mode>>>(
            Id, "mode", 0, UINT8_MAX, Attributes::Mode::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::WindowCovering::SafetyStatus>>>(
            Id, "safety-status", 0, UINT16_MAX, Attributes::SafetyStatus::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                  //
        make_unique<SubscribeAttribute>(Id, "type", Attributes::Type::Id, credsIssuerConfig),    //
        make_unique<SubscribeAttribute>(Id, "physical-closed-limit-lift", Attributes::PhysicalClosedLimitLift::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "physical-closed-limit-tilt", Attributes::PhysicalClosedLimitTilt::Id,
                                        credsIssuerConfig),                                                                   //
        make_unique<SubscribeAttribute>(Id, "current-position-lift", Attributes::CurrentPositionLift::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "current-position-tilt", Attributes::CurrentPositionTilt::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "number-of-actuations-lift", Attributes::NumberOfActuationsLift::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "number-of-actuations-tilt", Attributes::NumberOfActuationsTilt::Id,
                                        credsIssuerConfig),                                                    //
        make_unique<SubscribeAttribute>(Id, "config-status", Attributes::ConfigStatus::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "current-position-lift-percentage", Attributes::CurrentPositionLiftPercentage::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "current-position-tilt-percentage", Attributes::CurrentPositionTiltPercentage::Id,
                                        credsIssuerConfig),                                                              //
        make_unique<SubscribeAttribute>(Id, "operational-status", Attributes::OperationalStatus::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "target-position-lift-percent100ths", Attributes::TargetPositionLiftPercent100ths::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "target-position-tilt-percent100ths", Attributes::TargetPositionTiltPercent100ths::Id,
                                        credsIssuerConfig),                                                         //
        make_unique<SubscribeAttribute>(Id, "end-product-type", Attributes::EndProductType::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "current-position-lift-percent100ths", Attributes::CurrentPositionLiftPercent100ths::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "current-position-tilt-percent100ths", Attributes::CurrentPositionTiltPercent100ths::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "installed-open-limit-lift", Attributes::InstalledOpenLimitLift::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "installed-closed-limit-lift", Attributes::InstalledClosedLimitLift::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "installed-open-limit-tilt", Attributes::InstalledOpenLimitTilt::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "installed-closed-limit-tilt", Attributes::InstalledClosedLimitTilt::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "mode", Attributes::Mode::Id, credsIssuerConfig),                                   //
        make_unique<SubscribeAttribute>(Id, "safety-status", Attributes::SafetyStatus::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterBarrierControl(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::BarrierControl;

    const char * clusterName = "BarrierControl";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                      //
        make_unique<BarrierControlBarrierControlGoToPercent>(credsIssuerConfig), //
        make_unique<BarrierControlBarrierControlStop>(credsIssuerConfig),        //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                               //
        make_unique<ReadAttribute>(Id, "barrier-moving-state", Attributes::BarrierMovingState::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "barrier-safety-status", Attributes::BarrierSafetyStatus::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "barrier-capabilities", Attributes::BarrierCapabilities::Id, credsIssuerConfig),  //
        make_unique<ReadAttribute>(Id, "barrier-open-events", Attributes::BarrierOpenEvents::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "barrier-close-events", Attributes::BarrierCloseEvents::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "barrier-command-open-events", Attributes::BarrierCommandOpenEvents::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "barrier-command-close-events", Attributes::BarrierCommandCloseEvents::Id,
                                   credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "barrier-open-period", Attributes::BarrierOpenPeriod::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "barrier-close-period", Attributes::BarrierClosePeriod::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "barrier-position", Attributes::BarrierPosition::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<uint8_t>>(Id, "barrier-moving-state", 0, UINT8_MAX, Attributes::BarrierMovingState::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "barrier-safety-status", 0, UINT16_MAX, Attributes::BarrierSafetyStatus::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "barrier-capabilities", 0, UINT8_MAX, Attributes::BarrierCapabilities::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "barrier-open-events", 0, UINT16_MAX, Attributes::BarrierOpenEvents::Id,
                                              WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "barrier-close-events", 0, UINT16_MAX, Attributes::BarrierCloseEvents::Id,
                                              WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "barrier-command-open-events", 0, UINT16_MAX,
                                              Attributes::BarrierCommandOpenEvents::Id, WriteCommandType::kWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "barrier-command-close-events", 0, UINT16_MAX,
                                              Attributes::BarrierCommandCloseEvents::Id, WriteCommandType::kWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "barrier-open-period", 0, UINT16_MAX, Attributes::BarrierOpenPeriod::Id,
                                              WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "barrier-close-period", 0, UINT16_MAX, Attributes::BarrierClosePeriod::Id,
                                              WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "barrier-position", 0, UINT8_MAX, Attributes::BarrierPosition::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                              //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                               //
        make_unique<SubscribeAttribute>(Id, "barrier-moving-state", Attributes::BarrierMovingState::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "barrier-safety-status", Attributes::BarrierSafetyStatus::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "barrier-capabilities", Attributes::BarrierCapabilities::Id, credsIssuerConfig),  //
        make_unique<SubscribeAttribute>(Id, "barrier-open-events", Attributes::BarrierOpenEvents::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "barrier-close-events", Attributes::BarrierCloseEvents::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "barrier-command-open-events", Attributes::BarrierCommandOpenEvents::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "barrier-command-close-events", Attributes::BarrierCommandCloseEvents::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "barrier-open-period", Attributes::BarrierOpenPeriod::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "barrier-close-period", Attributes::BarrierClosePeriod::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "barrier-position", Attributes::BarrierPosition::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterPumpConfigurationAndControl(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::PumpConfigurationAndControl;

    const char * clusterName = "PumpConfigurationAndControl";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "max-pressure", Attributes::MaxPressure::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "max-speed", Attributes::MaxSpeed::Id, credsIssuerConfig),                              //
        make_unique<ReadAttribute>(Id, "max-flow", Attributes::MaxFlow::Id, credsIssuerConfig),                                //
        make_unique<ReadAttribute>(Id, "min-const-pressure", Attributes::MinConstPressure::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "max-const-pressure", Attributes::MaxConstPressure::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "min-comp-pressure", Attributes::MinCompPressure::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "max-comp-pressure", Attributes::MaxCompPressure::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "min-const-speed", Attributes::MinConstSpeed::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "max-const-speed", Attributes::MaxConstSpeed::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "min-const-flow", Attributes::MinConstFlow::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "max-const-flow", Attributes::MaxConstFlow::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "min-const-temp", Attributes::MinConstTemp::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "max-const-temp", Attributes::MaxConstTemp::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "pump-status", Attributes::PumpStatus::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "effective-operation-mode", Attributes::EffectiveOperationMode::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "effective-control-mode", Attributes::EffectiveControlMode::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "capacity", Attributes::Capacity::Id, credsIssuerConfig),                               //
        make_unique<ReadAttribute>(Id, "speed", Attributes::Speed::Id, credsIssuerConfig),                                     //
        make_unique<ReadAttribute>(Id, "lifetime-running-hours", Attributes::LifetimeRunningHours::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "power", Attributes::Power::Id, credsIssuerConfig),                                     //
        make_unique<ReadAttribute>(Id, "lifetime-energy-consumed", Attributes::LifetimeEnergyConsumed::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "operation-mode", Attributes::OperationMode::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "control-mode", Attributes::ControlMode::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                            //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),                //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                                  //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int16_t>>>(Id, "max-pressure", INT16_MIN, INT16_MAX,
                                                                             Attributes::MaxPressure::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint16_t>>>(
            Id, "max-speed", 0, UINT16_MAX, Attributes::MaxSpeed::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint16_t>>>(
            Id, "max-flow", 0, UINT16_MAX, Attributes::MaxFlow::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int16_t>>>(Id, "min-const-pressure", INT16_MIN, INT16_MAX,
                                                                             Attributes::MinConstPressure::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int16_t>>>(Id, "max-const-pressure", INT16_MIN, INT16_MAX,
                                                                             Attributes::MaxConstPressure::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int16_t>>>(Id, "min-comp-pressure", INT16_MIN, INT16_MAX,
                                                                             Attributes::MinCompPressure::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int16_t>>>(Id, "max-comp-pressure", INT16_MIN, INT16_MAX,
                                                                             Attributes::MaxCompPressure::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint16_t>>>(Id, "min-const-speed", 0, UINT16_MAX,
                                                                              Attributes::MinConstSpeed::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint16_t>>>(Id, "max-const-speed", 0, UINT16_MAX,
                                                                              Attributes::MaxConstSpeed::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint16_t>>>(
            Id, "min-const-flow", 0, UINT16_MAX, Attributes::MinConstFlow::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint16_t>>>(
            Id, "max-const-flow", 0, UINT16_MAX, Attributes::MaxConstFlow::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int16_t>>>(Id, "min-const-temp", INT16_MIN, INT16_MAX,
                                                                             Attributes::MinConstTemp::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int16_t>>>(Id, "max-const-temp", INT16_MIN, INT16_MAX,
                                                                             Attributes::MaxConstTemp::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::PumpConfigurationAndControl::PumpStatusBitmap>>>(
            Id, "pump-status", 0, UINT16_MAX, Attributes::PumpStatus::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::PumpConfigurationAndControl::OperationModeEnum>>(
            Id, "effective-operation-mode", 0, UINT8_MAX, Attributes::EffectiveOperationMode::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::PumpConfigurationAndControl::ControlModeEnum>>(
            Id, "effective-control-mode", 0, UINT8_MAX, Attributes::EffectiveControlMode::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int16_t>>>(
            Id, "capacity", INT16_MIN, INT16_MAX, Attributes::Capacity::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint16_t>>>(Id, "speed", 0, UINT16_MAX, Attributes::Speed::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(Id, "lifetime-running-hours", 0, UINT32_MAX,
                                                                              Attributes::LifetimeRunningHours::Id,
                                                                              WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(Id, "power", 0, UINT32_MAX, Attributes::Power::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(Id, "lifetime-energy-consumed", 0, UINT32_MAX,
                                                                              Attributes::LifetimeEnergyConsumed::Id,
                                                                              WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::PumpConfigurationAndControl::OperationModeEnum>>(
            Id, "operation-mode", 0, UINT8_MAX, Attributes::OperationMode::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::PumpConfigurationAndControl::ControlModeEnum>>(
            Id, "control-mode", 0, UINT8_MAX, Attributes::ControlMode::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                         //
        make_unique<SubscribeAttribute>(Id, "max-pressure", Attributes::MaxPressure::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "max-speed", Attributes::MaxSpeed::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "max-flow", Attributes::MaxFlow::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "min-const-pressure", Attributes::MinConstPressure::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "max-const-pressure", Attributes::MaxConstPressure::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "min-comp-pressure", Attributes::MinCompPressure::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "max-comp-pressure", Attributes::MaxCompPressure::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "min-const-speed", Attributes::MinConstSpeed::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "max-const-speed", Attributes::MaxConstSpeed::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "min-const-flow", Attributes::MinConstFlow::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "max-const-flow", Attributes::MaxConstFlow::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "min-const-temp", Attributes::MinConstTemp::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "max-const-temp", Attributes::MaxConstTemp::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "pump-status", Attributes::PumpStatus::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "effective-operation-mode", Attributes::EffectiveOperationMode::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "effective-control-mode", Attributes::EffectiveControlMode::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "capacity", Attributes::Capacity::Id, credsIssuerConfig),                           //
        make_unique<SubscribeAttribute>(Id, "speed", Attributes::Speed::Id, credsIssuerConfig),                                 //
        make_unique<SubscribeAttribute>(Id, "lifetime-running-hours", Attributes::LifetimeRunningHours::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "power", Attributes::Power::Id, credsIssuerConfig),                                 //
        make_unique<SubscribeAttribute>(Id, "lifetime-energy-consumed", Attributes::LifetimeEnergyConsumed::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "operation-mode", Attributes::OperationMode::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "control-mode", Attributes::ControlMode::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                                            //
        make_unique<ReadEvent>(Id, "supply-voltage-low", Events::SupplyVoltageLow::Id, credsIssuerConfig),                        //
        make_unique<ReadEvent>(Id, "supply-voltage-high", Events::SupplyVoltageHigh::Id, credsIssuerConfig),                      //
        make_unique<ReadEvent>(Id, "power-missing-phase", Events::PowerMissingPhase::Id, credsIssuerConfig),                      //
        make_unique<ReadEvent>(Id, "system-pressure-low", Events::SystemPressureLow::Id, credsIssuerConfig),                      //
        make_unique<ReadEvent>(Id, "system-pressure-high", Events::SystemPressureHigh::Id, credsIssuerConfig),                    //
        make_unique<ReadEvent>(Id, "dry-running", Events::DryRunning::Id, credsIssuerConfig),                                     //
        make_unique<ReadEvent>(Id, "motor-temperature-high", Events::MotorTemperatureHigh::Id, credsIssuerConfig),                //
        make_unique<ReadEvent>(Id, "pump-motor-fatal-failure", Events::PumpMotorFatalFailure::Id, credsIssuerConfig),             //
        make_unique<ReadEvent>(Id, "electronic-temperature-high", Events::ElectronicTemperatureHigh::Id, credsIssuerConfig),      //
        make_unique<ReadEvent>(Id, "pump-blocked", Events::PumpBlocked::Id, credsIssuerConfig),                                   //
        make_unique<ReadEvent>(Id, "sensor-failure", Events::SensorFailure::Id, credsIssuerConfig),                               //
        make_unique<ReadEvent>(Id, "electronic-non-fatal-failure", Events::ElectronicNonFatalFailure::Id, credsIssuerConfig),     //
        make_unique<ReadEvent>(Id, "electronic-fatal-failure", Events::ElectronicFatalFailure::Id, credsIssuerConfig),            //
        make_unique<ReadEvent>(Id, "general-fault", Events::GeneralFault::Id, credsIssuerConfig),                                 //
        make_unique<ReadEvent>(Id, "leakage", Events::Leakage::Id, credsIssuerConfig),                                            //
        make_unique<ReadEvent>(Id, "air-detection", Events::AirDetection::Id, credsIssuerConfig),                                 //
        make_unique<ReadEvent>(Id, "turbine-operation", Events::TurbineOperation::Id, credsIssuerConfig),                         //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                                       //
        make_unique<SubscribeEvent>(Id, "supply-voltage-low", Events::SupplyVoltageLow::Id, credsIssuerConfig),                   //
        make_unique<SubscribeEvent>(Id, "supply-voltage-high", Events::SupplyVoltageHigh::Id, credsIssuerConfig),                 //
        make_unique<SubscribeEvent>(Id, "power-missing-phase", Events::PowerMissingPhase::Id, credsIssuerConfig),                 //
        make_unique<SubscribeEvent>(Id, "system-pressure-low", Events::SystemPressureLow::Id, credsIssuerConfig),                 //
        make_unique<SubscribeEvent>(Id, "system-pressure-high", Events::SystemPressureHigh::Id, credsIssuerConfig),               //
        make_unique<SubscribeEvent>(Id, "dry-running", Events::DryRunning::Id, credsIssuerConfig),                                //
        make_unique<SubscribeEvent>(Id, "motor-temperature-high", Events::MotorTemperatureHigh::Id, credsIssuerConfig),           //
        make_unique<SubscribeEvent>(Id, "pump-motor-fatal-failure", Events::PumpMotorFatalFailure::Id, credsIssuerConfig),        //
        make_unique<SubscribeEvent>(Id, "electronic-temperature-high", Events::ElectronicTemperatureHigh::Id, credsIssuerConfig), //
        make_unique<SubscribeEvent>(Id, "pump-blocked", Events::PumpBlocked::Id, credsIssuerConfig),                              //
        make_unique<SubscribeEvent>(Id, "sensor-failure", Events::SensorFailure::Id, credsIssuerConfig),                          //
        make_unique<SubscribeEvent>(Id, "electronic-non-fatal-failure", Events::ElectronicNonFatalFailure::Id,
                                    credsIssuerConfig),                                                                     //
        make_unique<SubscribeEvent>(Id, "electronic-fatal-failure", Events::ElectronicFatalFailure::Id, credsIssuerConfig), //
        make_unique<SubscribeEvent>(Id, "general-fault", Events::GeneralFault::Id, credsIssuerConfig),                      //
        make_unique<SubscribeEvent>(Id, "leakage", Events::Leakage::Id, credsIssuerConfig),                                 //
        make_unique<SubscribeEvent>(Id, "air-detection", Events::AirDetection::Id, credsIssuerConfig),                      //
        make_unique<SubscribeEvent>(Id, "turbine-operation", Events::TurbineOperation::Id, credsIssuerConfig),              //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterThermostat(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::Thermostat;

    const char * clusterName = "Thermostat";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                          //
        make_unique<ThermostatSetpointRaiseLower>(credsIssuerConfig),                //
        make_unique<ThermostatSetWeeklySchedule>(credsIssuerConfig),                 //
        make_unique<ThermostatGetWeeklySchedule>(credsIssuerConfig),                 //
        make_unique<ThermostatClearWeeklySchedule>(credsIssuerConfig),               //
        make_unique<ThermostatSetActiveScheduleRequest>(credsIssuerConfig),          //
        make_unique<ThermostatSetActivePresetRequest>(credsIssuerConfig),            //
        make_unique<ThermostatStartPresetsSchedulesEditRequest>(credsIssuerConfig),  //
        make_unique<ThermostatCancelPresetsSchedulesEditRequest>(credsIssuerConfig), //
        make_unique<ThermostatCommitPresetsSchedulesRequest>(credsIssuerConfig),     //
        make_unique<ThermostatCancelSetActivePresetRequest>(credsIssuerConfig),      //
        make_unique<ThermostatSetTemperatureSetpointHoldPolicy>(credsIssuerConfig),  //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                            //
        make_unique<ReadAttribute>(Id, "local-temperature", Attributes::LocalTemperature::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "outdoor-temperature", Attributes::OutdoorTemperature::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "occupancy", Attributes::Occupancy::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "abs-min-heat-setpoint-limit", Attributes::AbsMinHeatSetpointLimit::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "abs-max-heat-setpoint-limit", Attributes::AbsMaxHeatSetpointLimit::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "abs-min-cool-setpoint-limit", Attributes::AbsMinCoolSetpointLimit::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "abs-max-cool-setpoint-limit", Attributes::AbsMaxCoolSetpointLimit::Id,
                                   credsIssuerConfig),                                                          //
        make_unique<ReadAttribute>(Id, "picooling-demand", Attributes::PICoolingDemand::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "piheating-demand", Attributes::PIHeatingDemand::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "hvacsystem-type-configuration", Attributes::HVACSystemTypeConfiguration::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "local-temperature-calibration", Attributes::LocalTemperatureCalibration::Id,
                                   credsIssuerConfig),                                                                           //
        make_unique<ReadAttribute>(Id, "occupied-cooling-setpoint", Attributes::OccupiedCoolingSetpoint::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "occupied-heating-setpoint", Attributes::OccupiedHeatingSetpoint::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "unoccupied-cooling-setpoint", Attributes::UnoccupiedCoolingSetpoint::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "unoccupied-heating-setpoint", Attributes::UnoccupiedHeatingSetpoint::Id,
                                   credsIssuerConfig),                                                                      //
        make_unique<ReadAttribute>(Id, "min-heat-setpoint-limit", Attributes::MinHeatSetpointLimit::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "max-heat-setpoint-limit", Attributes::MaxHeatSetpointLimit::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "min-cool-setpoint-limit", Attributes::MinCoolSetpointLimit::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "max-cool-setpoint-limit", Attributes::MaxCoolSetpointLimit::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "min-setpoint-dead-band", Attributes::MinSetpointDeadBand::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "remote-sensing", Attributes::RemoteSensing::Id, credsIssuerConfig),                 //
        make_unique<ReadAttribute>(Id, "control-sequence-of-operation", Attributes::ControlSequenceOfOperation::Id,
                                   credsIssuerConfig),                                                                       //
        make_unique<ReadAttribute>(Id, "system-mode", Attributes::SystemMode::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "thermostat-running-mode", Attributes::ThermostatRunningMode::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "start-of-week", Attributes::StartOfWeek::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "number-of-weekly-transitions", Attributes::NumberOfWeeklyTransitions::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "number-of-daily-transitions", Attributes::NumberOfDailyTransitions::Id,
                                   credsIssuerConfig),                                                                           //
        make_unique<ReadAttribute>(Id, "temperature-setpoint-hold", Attributes::TemperatureSetpointHold::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "temperature-setpoint-hold-duration", Attributes::TemperatureSetpointHoldDuration::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "thermostat-programming-operation-mode", Attributes::ThermostatProgrammingOperationMode::Id,
                                   credsIssuerConfig),                                                                         //
        make_unique<ReadAttribute>(Id, "thermostat-running-state", Attributes::ThermostatRunningState::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "setpoint-change-source", Attributes::SetpointChangeSource::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "setpoint-change-amount", Attributes::SetpointChangeAmount::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "setpoint-change-source-timestamp", Attributes::SetpointChangeSourceTimestamp::Id,
                                   credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "occupied-setback", Attributes::OccupiedSetback::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "occupied-setback-min", Attributes::OccupiedSetbackMin::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "occupied-setback-max", Attributes::OccupiedSetbackMax::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "unoccupied-setback", Attributes::UnoccupiedSetback::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "unoccupied-setback-min", Attributes::UnoccupiedSetbackMin::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "unoccupied-setback-max", Attributes::UnoccupiedSetbackMax::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "emergency-heat-delta", Attributes::EmergencyHeatDelta::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "actype", Attributes::ACType::Id, credsIssuerConfig),                               //
        make_unique<ReadAttribute>(Id, "accapacity", Attributes::ACCapacity::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "acrefrigerant-type", Attributes::ACRefrigerantType::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "accompressor-type", Attributes::ACCompressorType::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "acerror-code", Attributes::ACErrorCode::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "aclouver-position", Attributes::ACLouverPosition::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "accoil-temperature", Attributes::ACCoilTemperature::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "accapacityformat", Attributes::ACCapacityformat::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "preset-types", Attributes::PresetTypes::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "schedule-types", Attributes::ScheduleTypes::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "number-of-presets", Attributes::NumberOfPresets::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "number-of-schedules", Attributes::NumberOfSchedules::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "number-of-schedule-transitions", Attributes::NumberOfScheduleTransitions::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "number-of-schedule-transition-per-day", Attributes::NumberOfScheduleTransitionPerDay::Id,
                                   credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "active-preset-handle", Attributes::ActivePresetHandle::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "active-schedule-handle", Attributes::ActiveScheduleHandle::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "presets", Attributes::Presets::Id, credsIssuerConfig),                             //
        make_unique<ReadAttribute>(Id, "schedules", Attributes::Schedules::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "presets-schedules-editable", Attributes::PresetsSchedulesEditable::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "temperature-setpoint-hold-policy", Attributes::TemperatureSetpointHoldPolicy::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "setpoint-hold-expiry-timestamp", Attributes::SetpointHoldExpiryTimestamp::Id,
                                   credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "queued-preset", Attributes::QueuedPreset::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int16_t>>>(Id, "local-temperature", INT16_MIN, INT16_MAX,
                                                                             Attributes::LocalTemperature::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int16_t>>>(Id, "outdoor-temperature", INT16_MIN, INT16_MAX,
                                                                             Attributes::OutdoorTemperature::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "occupancy", 0, UINT8_MAX, Attributes::Occupancy::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "abs-min-heat-setpoint-limit", INT16_MIN, INT16_MAX,
                                             Attributes::AbsMinHeatSetpointLimit::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "abs-max-heat-setpoint-limit", INT16_MIN, INT16_MAX,
                                             Attributes::AbsMaxHeatSetpointLimit::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "abs-min-cool-setpoint-limit", INT16_MIN, INT16_MAX,
                                             Attributes::AbsMinCoolSetpointLimit::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "abs-max-cool-setpoint-limit", INT16_MIN, INT16_MAX,
                                             Attributes::AbsMaxCoolSetpointLimit::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "picooling-demand", 0, UINT8_MAX, Attributes::PICoolingDemand::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "piheating-demand", 0, UINT8_MAX, Attributes::PIHeatingDemand::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "hvacsystem-type-configuration", 0, UINT8_MAX,
                                             Attributes::HVACSystemTypeConfiguration::Id, WriteCommandType::kWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int8_t>>(Id, "local-temperature-calibration", INT8_MIN, INT8_MAX,
                                            Attributes::LocalTemperatureCalibration::Id, WriteCommandType::kWrite,
                                            credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "occupied-cooling-setpoint", INT16_MIN, INT16_MAX,
                                             Attributes::OccupiedCoolingSetpoint::Id, WriteCommandType::kWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "occupied-heating-setpoint", INT16_MIN, INT16_MAX,
                                             Attributes::OccupiedHeatingSetpoint::Id, WriteCommandType::kWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "unoccupied-cooling-setpoint", INT16_MIN, INT16_MAX,
                                             Attributes::UnoccupiedCoolingSetpoint::Id, WriteCommandType::kWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "unoccupied-heating-setpoint", INT16_MIN, INT16_MAX,
                                             Attributes::UnoccupiedHeatingSetpoint::Id, WriteCommandType::kWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "min-heat-setpoint-limit", INT16_MIN, INT16_MAX,
                                             Attributes::MinHeatSetpointLimit::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "max-heat-setpoint-limit", INT16_MIN, INT16_MAX,
                                             Attributes::MaxHeatSetpointLimit::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "min-cool-setpoint-limit", INT16_MIN, INT16_MAX,
                                             Attributes::MinCoolSetpointLimit::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "max-cool-setpoint-limit", INT16_MIN, INT16_MAX,
                                             Attributes::MaxCoolSetpointLimit::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int8_t>>(Id, "min-setpoint-dead-band", INT8_MIN, INT8_MAX, Attributes::MinSetpointDeadBand::Id,
                                            WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::Thermostat::RemoteSensingBitmap>>>(
            Id, "remote-sensing", 0, UINT8_MAX, Attributes::RemoteSensing::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::Thermostat::ControlSequenceOfOperationEnum>>(
            Id, "control-sequence-of-operation", 0, UINT8_MAX, Attributes::ControlSequenceOfOperation::Id, WriteCommandType::kWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::Thermostat::SystemModeEnum>>(
            Id, "system-mode", 0, UINT8_MAX, Attributes::SystemMode::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::Thermostat::ThermostatRunningModeEnum>>(
            Id, "thermostat-running-mode", 0, UINT8_MAX, Attributes::ThermostatRunningMode::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::Thermostat::StartOfWeekEnum>>(
            Id, "start-of-week", 0, UINT8_MAX, Attributes::StartOfWeek::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "number-of-weekly-transitions", 0, UINT8_MAX,
                                             Attributes::NumberOfWeeklyTransitions::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "number-of-daily-transitions", 0, UINT8_MAX,
                                             Attributes::NumberOfDailyTransitions::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::Thermostat::TemperatureSetpointHoldEnum>>(
            Id, "temperature-setpoint-hold", 0, UINT8_MAX, Attributes::TemperatureSetpointHold::Id, WriteCommandType::kWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint16_t>>>(
            Id, "temperature-setpoint-hold-duration", 0, UINT16_MAX, Attributes::TemperatureSetpointHoldDuration::Id,
            WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::Thermostat::ProgrammingOperationModeBitmap>>>(
            Id, "thermostat-programming-operation-mode", 0, UINT8_MAX, Attributes::ThermostatProgrammingOperationMode::Id,
            WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::Thermostat::RelayStateBitmap>>>(
            Id, "thermostat-running-state", 0, UINT16_MAX, Attributes::ThermostatRunningState::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::Thermostat::SetpointChangeSourceEnum>>(
            Id, "setpoint-change-source", 0, UINT8_MAX, Attributes::SetpointChangeSource::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int16_t>>>(Id, "setpoint-change-amount", INT16_MIN, INT16_MAX,
                                                                             Attributes::SetpointChangeAmount::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "setpoint-change-source-timestamp", 0, UINT32_MAX,
                                              Attributes::SetpointChangeSourceTimestamp::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(
            Id, "occupied-setback", 0, UINT8_MAX, Attributes::OccupiedSetback::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(Id, "occupied-setback-min", 0, UINT8_MAX,
                                                                             Attributes::OccupiedSetbackMin::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(Id, "occupied-setback-max", 0, UINT8_MAX,
                                                                             Attributes::OccupiedSetbackMax::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(Id, "unoccupied-setback", 0, UINT8_MAX,
                                                                             Attributes::UnoccupiedSetback::Id,
                                                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(Id, "unoccupied-setback-min", 0, UINT8_MAX,
                                                                             Attributes::UnoccupiedSetbackMin::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(Id, "unoccupied-setback-max", 0, UINT8_MAX,
                                                                             Attributes::UnoccupiedSetbackMax::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "emergency-heat-delta", 0, UINT8_MAX, Attributes::EmergencyHeatDelta::Id,
                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::Thermostat::ACTypeEnum>>(Id, "actype", 0, UINT8_MAX, Attributes::ACType::Id,
                                                                                 WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "accapacity", 0, UINT16_MAX, Attributes::ACCapacity::Id, WriteCommandType::kWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::Thermostat::ACRefrigerantTypeEnum>>(
            Id, "acrefrigerant-type", 0, UINT8_MAX, Attributes::ACRefrigerantType::Id, WriteCommandType::kWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::Thermostat::ACCompressorTypeEnum>>(
            Id, "accompressor-type", 0, UINT8_MAX, Attributes::ACCompressorType::Id, WriteCommandType::kWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::Thermostat::ACErrorCodeBitmap>>>(
            Id, "acerror-code", 0, UINT32_MAX, Attributes::ACErrorCode::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::Thermostat::ACLouverPositionEnum>>(
            Id, "aclouver-position", 0, UINT8_MAX, Attributes::ACLouverPosition::Id, WriteCommandType::kWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int16_t>>>(Id, "accoil-temperature", INT16_MIN, INT16_MAX,
                                                                             Attributes::ACCoilTemperature::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::Thermostat::ACCapacityFormatEnum>>(
            Id, "accapacityformat", 0, UINT8_MAX, Attributes::ACCapacityformat::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::Thermostat::Structs::PresetTypeStruct::Type>>>(
            Id, "preset-types", Attributes::PresetTypes::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::Thermostat::Structs::ScheduleTypeStruct::Type>>>(
            Id, "schedule-types", Attributes::ScheduleTypes::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "number-of-presets", 0, UINT8_MAX, Attributes::NumberOfPresets::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "number-of-schedules", 0, UINT8_MAX, Attributes::NumberOfSchedules::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "number-of-schedule-transitions", 0, UINT8_MAX,
                                             Attributes::NumberOfScheduleTransitions::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(
            Id, "number-of-schedule-transition-per-day", 0, UINT8_MAX, Attributes::NumberOfScheduleTransitionPerDay::Id,
            WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::ByteSpan>>>(
            Id, "active-preset-handle", Attributes::ActivePresetHandle::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::ByteSpan>>>(
            Id, "active-schedule-handle", Attributes::ActiveScheduleHandle::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::Thermostat::Structs::PresetStruct::Type>>>(
            Id, "presets", Attributes::Presets::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::Thermostat::Structs::ScheduleStruct::Type>>>(
            Id, "schedules", Attributes::Schedules::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<bool>>(Id, "presets-schedules-editable", 0, 1, Attributes::PresetsSchedulesEditable::Id,
                                          WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::Thermostat::TemperatureSetpointHoldPolicyBitmap>>>(
            Id, "temperature-setpoint-hold-policy", 0, UINT8_MAX, Attributes::TemperatureSetpointHoldPolicy::Id,
            WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(Id, "setpoint-hold-expiry-timestamp", 0, UINT32_MAX,
                                                                              Attributes::SetpointHoldExpiryTimestamp::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::Nullable<chip::app::Clusters::Thermostat::Structs::QueuedPresetStruct::Type>>>(
            Id, "queued-preset", Attributes::QueuedPreset::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                           //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                            //
        make_unique<SubscribeAttribute>(Id, "local-temperature", Attributes::LocalTemperature::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "outdoor-temperature", Attributes::OutdoorTemperature::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "occupancy", Attributes::Occupancy::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "abs-min-heat-setpoint-limit", Attributes::AbsMinHeatSetpointLimit::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "abs-max-heat-setpoint-limit", Attributes::AbsMaxHeatSetpointLimit::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "abs-min-cool-setpoint-limit", Attributes::AbsMinCoolSetpointLimit::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "abs-max-cool-setpoint-limit", Attributes::AbsMaxCoolSetpointLimit::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "picooling-demand", Attributes::PICoolingDemand::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "piheating-demand", Attributes::PIHeatingDemand::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "hvacsystem-type-configuration", Attributes::HVACSystemTypeConfiguration::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "local-temperature-calibration", Attributes::LocalTemperatureCalibration::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "occupied-cooling-setpoint", Attributes::OccupiedCoolingSetpoint::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "occupied-heating-setpoint", Attributes::OccupiedHeatingSetpoint::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "unoccupied-cooling-setpoint", Attributes::UnoccupiedCoolingSetpoint::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "unoccupied-heating-setpoint", Attributes::UnoccupiedHeatingSetpoint::Id,
                                        credsIssuerConfig),                                                                      //
        make_unique<SubscribeAttribute>(Id, "min-heat-setpoint-limit", Attributes::MinHeatSetpointLimit::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "max-heat-setpoint-limit", Attributes::MaxHeatSetpointLimit::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "min-cool-setpoint-limit", Attributes::MinCoolSetpointLimit::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "max-cool-setpoint-limit", Attributes::MaxCoolSetpointLimit::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "min-setpoint-dead-band", Attributes::MinSetpointDeadBand::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "remote-sensing", Attributes::RemoteSensing::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "control-sequence-of-operation", Attributes::ControlSequenceOfOperation::Id,
                                        credsIssuerConfig),                                                                       //
        make_unique<SubscribeAttribute>(Id, "system-mode", Attributes::SystemMode::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "thermostat-running-mode", Attributes::ThermostatRunningMode::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "start-of-week", Attributes::StartOfWeek::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "number-of-weekly-transitions", Attributes::NumberOfWeeklyTransitions::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "number-of-daily-transitions", Attributes::NumberOfDailyTransitions::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "temperature-setpoint-hold", Attributes::TemperatureSetpointHold::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "temperature-setpoint-hold-duration", Attributes::TemperatureSetpointHoldDuration::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "thermostat-programming-operation-mode",
                                        Attributes::ThermostatProgrammingOperationMode::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "thermostat-running-state", Attributes::ThermostatRunningState::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "setpoint-change-source", Attributes::SetpointChangeSource::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "setpoint-change-amount", Attributes::SetpointChangeAmount::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "setpoint-change-source-timestamp", Attributes::SetpointChangeSourceTimestamp::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "occupied-setback", Attributes::OccupiedSetback::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "occupied-setback-min", Attributes::OccupiedSetbackMin::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "occupied-setback-max", Attributes::OccupiedSetbackMax::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "unoccupied-setback", Attributes::UnoccupiedSetback::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "unoccupied-setback-min", Attributes::UnoccupiedSetbackMin::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "unoccupied-setback-max", Attributes::UnoccupiedSetbackMax::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "emergency-heat-delta", Attributes::EmergencyHeatDelta::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "actype", Attributes::ACType::Id, credsIssuerConfig),                               //
        make_unique<SubscribeAttribute>(Id, "accapacity", Attributes::ACCapacity::Id, credsIssuerConfig),                       //
        make_unique<SubscribeAttribute>(Id, "acrefrigerant-type", Attributes::ACRefrigerantType::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "accompressor-type", Attributes::ACCompressorType::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "acerror-code", Attributes::ACErrorCode::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "aclouver-position", Attributes::ACLouverPosition::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "accoil-temperature", Attributes::ACCoilTemperature::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "accapacityformat", Attributes::ACCapacityformat::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "preset-types", Attributes::PresetTypes::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "schedule-types", Attributes::ScheduleTypes::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "number-of-presets", Attributes::NumberOfPresets::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "number-of-schedules", Attributes::NumberOfSchedules::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "number-of-schedule-transitions", Attributes::NumberOfScheduleTransitions::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "number-of-schedule-transition-per-day",
                                        Attributes::NumberOfScheduleTransitionPerDay::Id, credsIssuerConfig),                   //
        make_unique<SubscribeAttribute>(Id, "active-preset-handle", Attributes::ActivePresetHandle::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "active-schedule-handle", Attributes::ActiveScheduleHandle::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "presets", Attributes::Presets::Id, credsIssuerConfig),                             //
        make_unique<SubscribeAttribute>(Id, "schedules", Attributes::Schedules::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "presets-schedules-editable", Attributes::PresetsSchedulesEditable::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "temperature-setpoint-hold-policy", Attributes::TemperatureSetpointHoldPolicy::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "setpoint-hold-expiry-timestamp", Attributes::SetpointHoldExpiryTimestamp::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "queued-preset", Attributes::QueuedPreset::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterFanControl(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::FanControl;

    const char * clusterName = "FanControl";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        make_unique<FanControlStep>(credsIssuerConfig),     //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "fan-mode", Attributes::FanMode::Id, credsIssuerConfig),                            //
        make_unique<ReadAttribute>(Id, "fan-mode-sequence", Attributes::FanModeSequence::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "percent-setting", Attributes::PercentSetting::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "percent-current", Attributes::PercentCurrent::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "speed-max", Attributes::SpeedMax::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "speed-setting", Attributes::SpeedSetting::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "speed-current", Attributes::SpeedCurrent::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "rock-support", Attributes::RockSupport::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "rock-setting", Attributes::RockSetting::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "wind-support", Attributes::WindSupport::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "wind-setting", Attributes::WindSetting::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "airflow-direction", Attributes::AirflowDirection::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::app::Clusters::FanControl::FanModeEnum>>(
            Id, "fan-mode", 0, UINT8_MAX, Attributes::FanMode::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::FanControl::FanModeSequenceEnum>>(
            Id, "fan-mode-sequence", 0, UINT8_MAX, Attributes::FanModeSequence::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::Percent>>>(
            Id, "percent-setting", 0, UINT8_MAX, Attributes::PercentSetting::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::Percent>>(Id, "percent-current", 0, UINT8_MAX, Attributes::PercentCurrent::Id,
                                                   WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "speed-max", 0, UINT8_MAX, Attributes::SpeedMax::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(
            Id, "speed-setting", 0, UINT8_MAX, Attributes::SpeedSetting::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "speed-current", 0, UINT8_MAX, Attributes::SpeedCurrent::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::FanControl::RockBitmap>>>(
            Id, "rock-support", 0, UINT8_MAX, Attributes::RockSupport::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::FanControl::RockBitmap>>>(
            Id, "rock-setting", 0, UINT8_MAX, Attributes::RockSetting::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::FanControl::WindBitmap>>>(
            Id, "wind-support", 0, UINT8_MAX, Attributes::WindSupport::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::FanControl::WindBitmap>>>(
            Id, "wind-setting", 0, UINT8_MAX, Attributes::WindSetting::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::FanControl::AirflowDirectionEnum>>(
            Id, "airflow-direction", 0, UINT8_MAX, Attributes::AirflowDirection::Id, WriteCommandType::kWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "fan-mode", Attributes::FanMode::Id, credsIssuerConfig),                            //
        make_unique<SubscribeAttribute>(Id, "fan-mode-sequence", Attributes::FanModeSequence::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "percent-setting", Attributes::PercentSetting::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "percent-current", Attributes::PercentCurrent::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "speed-max", Attributes::SpeedMax::Id, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, "speed-setting", Attributes::SpeedSetting::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "speed-current", Attributes::SpeedCurrent::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "rock-support", Attributes::RockSupport::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "rock-setting", Attributes::RockSetting::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "wind-support", Attributes::WindSupport::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "wind-setting", Attributes::WindSetting::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "airflow-direction", Attributes::AirflowDirection::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterThermostatUserInterfaceConfiguration(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::ThermostatUserInterfaceConfiguration;

    const char * clusterName = "ThermostatUserInterfaceConfiguration";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "temperature-display-mode", Attributes::TemperatureDisplayMode::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "keypad-lockout", Attributes::KeypadLockout::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "schedule-programming-visibility", Attributes::ScheduleProgrammingVisibility::Id,
                                   credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::app::Clusters::ThermostatUserInterfaceConfiguration::TemperatureDisplayModeEnum>>(
            Id, "temperature-display-mode", 0, UINT8_MAX, Attributes::TemperatureDisplayMode::Id, WriteCommandType::kWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::ThermostatUserInterfaceConfiguration::KeypadLockoutEnum>>(
            Id, "keypad-lockout", 0, UINT8_MAX, Attributes::KeypadLockout::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::ThermostatUserInterfaceConfiguration::ScheduleProgrammingVisibilityEnum>>(
            Id, "schedule-programming-visibility", 0, UINT8_MAX, Attributes::ScheduleProgrammingVisibility::Id,
            WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                  //
        make_unique<SubscribeAttribute>(Id, "temperature-display-mode", Attributes::TemperatureDisplayMode::Id,
                                        credsIssuerConfig),                                                      //
        make_unique<SubscribeAttribute>(Id, "keypad-lockout", Attributes::KeypadLockout::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "schedule-programming-visibility", Attributes::ScheduleProgrammingVisibility::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterColorControl(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::ColorControl;

    const char * clusterName = "ColorControl";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                         //
        make_unique<ColorControlMoveToHue>(credsIssuerConfig),                      //
        make_unique<ColorControlMoveHue>(credsIssuerConfig),                        //
        make_unique<ColorControlStepHue>(credsIssuerConfig),                        //
        make_unique<ColorControlMoveToSaturation>(credsIssuerConfig),               //
        make_unique<ColorControlMoveSaturation>(credsIssuerConfig),                 //
        make_unique<ColorControlStepSaturation>(credsIssuerConfig),                 //
        make_unique<ColorControlMoveToHueAndSaturation>(credsIssuerConfig),         //
        make_unique<ColorControlMoveToColor>(credsIssuerConfig),                    //
        make_unique<ColorControlMoveColor>(credsIssuerConfig),                      //
        make_unique<ColorControlStepColor>(credsIssuerConfig),                      //
        make_unique<ColorControlMoveToColorTemperature>(credsIssuerConfig),         //
        make_unique<ColorControlEnhancedMoveToHue>(credsIssuerConfig),              //
        make_unique<ColorControlEnhancedMoveHue>(credsIssuerConfig),                //
        make_unique<ColorControlEnhancedStepHue>(credsIssuerConfig),                //
        make_unique<ColorControlEnhancedMoveToHueAndSaturation>(credsIssuerConfig), //
        make_unique<ColorControlColorLoopSet>(credsIssuerConfig),                   //
        make_unique<ColorControlStopMoveStep>(credsIssuerConfig),                   //
        make_unique<ColorControlMoveColorTemperature>(credsIssuerConfig),           //
        make_unique<ColorControlStepColorTemperature>(credsIssuerConfig),           //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "current-hue", Attributes::CurrentHue::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "current-saturation", Attributes::CurrentSaturation::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "remaining-time", Attributes::RemainingTime::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "current-x", Attributes::CurrentX::Id, credsIssuerConfig),                              //
        make_unique<ReadAttribute>(Id, "current-y", Attributes::CurrentY::Id, credsIssuerConfig),                              //
        make_unique<ReadAttribute>(Id, "drift-compensation", Attributes::DriftCompensation::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "compensation-text", Attributes::CompensationText::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "color-temperature-mireds", Attributes::ColorTemperatureMireds::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "color-mode", Attributes::ColorMode::Id, credsIssuerConfig),                            //
        make_unique<ReadAttribute>(Id, "options", Attributes::Options::Id, credsIssuerConfig),                                 //
        make_unique<ReadAttribute>(Id, "number-of-primaries", Attributes::NumberOfPrimaries::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "primary1x", Attributes::Primary1X::Id, credsIssuerConfig),                             //
        make_unique<ReadAttribute>(Id, "primary1y", Attributes::Primary1Y::Id, credsIssuerConfig),                             //
        make_unique<ReadAttribute>(Id, "primary1intensity", Attributes::Primary1Intensity::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "primary2x", Attributes::Primary2X::Id, credsIssuerConfig),                             //
        make_unique<ReadAttribute>(Id, "primary2y", Attributes::Primary2Y::Id, credsIssuerConfig),                             //
        make_unique<ReadAttribute>(Id, "primary2intensity", Attributes::Primary2Intensity::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "primary3x", Attributes::Primary3X::Id, credsIssuerConfig),                             //
        make_unique<ReadAttribute>(Id, "primary3y", Attributes::Primary3Y::Id, credsIssuerConfig),                             //
        make_unique<ReadAttribute>(Id, "primary3intensity", Attributes::Primary3Intensity::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "primary4x", Attributes::Primary4X::Id, credsIssuerConfig),                             //
        make_unique<ReadAttribute>(Id, "primary4y", Attributes::Primary4Y::Id, credsIssuerConfig),                             //
        make_unique<ReadAttribute>(Id, "primary4intensity", Attributes::Primary4Intensity::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "primary5x", Attributes::Primary5X::Id, credsIssuerConfig),                             //
        make_unique<ReadAttribute>(Id, "primary5y", Attributes::Primary5Y::Id, credsIssuerConfig),                             //
        make_unique<ReadAttribute>(Id, "primary5intensity", Attributes::Primary5Intensity::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "primary6x", Attributes::Primary6X::Id, credsIssuerConfig),                             //
        make_unique<ReadAttribute>(Id, "primary6y", Attributes::Primary6Y::Id, credsIssuerConfig),                             //
        make_unique<ReadAttribute>(Id, "primary6intensity", Attributes::Primary6Intensity::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "white-point-x", Attributes::WhitePointX::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "white-point-y", Attributes::WhitePointY::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "color-point-rx", Attributes::ColorPointRX::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "color-point-ry", Attributes::ColorPointRY::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "color-point-rintensity", Attributes::ColorPointRIntensity::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "color-point-gx", Attributes::ColorPointGX::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "color-point-gy", Attributes::ColorPointGY::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "color-point-gintensity", Attributes::ColorPointGIntensity::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "color-point-bx", Attributes::ColorPointBX::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "color-point-by", Attributes::ColorPointBY::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "color-point-bintensity", Attributes::ColorPointBIntensity::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "enhanced-current-hue", Attributes::EnhancedCurrentHue::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "enhanced-color-mode", Attributes::EnhancedColorMode::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "color-loop-active", Attributes::ColorLoopActive::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "color-loop-direction", Attributes::ColorLoopDirection::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "color-loop-time", Attributes::ColorLoopTime::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "color-loop-start-enhanced-hue", Attributes::ColorLoopStartEnhancedHue::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "color-loop-stored-enhanced-hue", Attributes::ColorLoopStoredEnhancedHue::Id,
                                   credsIssuerConfig),                                                              //
        make_unique<ReadAttribute>(Id, "color-capabilities", Attributes::ColorCapabilities::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "color-temp-physical-min-mireds", Attributes::ColorTempPhysicalMinMireds::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "color-temp-physical-max-mireds", Attributes::ColorTempPhysicalMaxMireds::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "couple-color-temp-to-level-min-mireds", Attributes::CoupleColorTempToLevelMinMireds::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "start-up-color-temperature-mireds", Attributes::StartUpColorTemperatureMireds::Id,
                                   credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<uint8_t>>(Id, "current-hue", 0, UINT8_MAX, Attributes::CurrentHue::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "current-saturation", 0, UINT8_MAX, Attributes::CurrentSaturation::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "remaining-time", 0, UINT16_MAX, Attributes::RemainingTime::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "current-x", 0, UINT16_MAX, Attributes::CurrentX::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "current-y", 0, UINT16_MAX, Attributes::CurrentY::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "drift-compensation", 0, UINT8_MAX, Attributes::DriftCompensation::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "compensation-text", Attributes::CompensationText::Id,
                                                    WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "color-temperature-mireds", 0, UINT16_MAX, Attributes::ColorTemperatureMireds::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "color-mode", 0, UINT8_MAX, Attributes::ColorMode::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "options", 0, UINT8_MAX, Attributes::Options::Id, WriteCommandType::kWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(Id, "number-of-primaries", 0, UINT8_MAX,
                                                                             Attributes::NumberOfPrimaries::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "primary1x", 0, UINT16_MAX, Attributes::Primary1X::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "primary1y", 0, UINT16_MAX, Attributes::Primary1Y::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(Id, "primary1intensity", 0, UINT8_MAX,
                                                                             Attributes::Primary1Intensity::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "primary2x", 0, UINT16_MAX, Attributes::Primary2X::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "primary2y", 0, UINT16_MAX, Attributes::Primary2Y::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(Id, "primary2intensity", 0, UINT8_MAX,
                                                                             Attributes::Primary2Intensity::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "primary3x", 0, UINT16_MAX, Attributes::Primary3X::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "primary3y", 0, UINT16_MAX, Attributes::Primary3Y::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(Id, "primary3intensity", 0, UINT8_MAX,
                                                                             Attributes::Primary3Intensity::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "primary4x", 0, UINT16_MAX, Attributes::Primary4X::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "primary4y", 0, UINT16_MAX, Attributes::Primary4Y::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(Id, "primary4intensity", 0, UINT8_MAX,
                                                                             Attributes::Primary4Intensity::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "primary5x", 0, UINT16_MAX, Attributes::Primary5X::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "primary5y", 0, UINT16_MAX, Attributes::Primary5Y::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(Id, "primary5intensity", 0, UINT8_MAX,
                                                                             Attributes::Primary5Intensity::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "primary6x", 0, UINT16_MAX, Attributes::Primary6X::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "primary6y", 0, UINT16_MAX, Attributes::Primary6Y::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(Id, "primary6intensity", 0, UINT8_MAX,
                                                                             Attributes::Primary6Intensity::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "white-point-x", 0, UINT16_MAX, Attributes::WhitePointX::Id,
                                              WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "white-point-y", 0, UINT16_MAX, Attributes::WhitePointY::Id,
                                              WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "color-point-rx", 0, UINT16_MAX, Attributes::ColorPointRX::Id,
                                              WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "color-point-ry", 0, UINT16_MAX, Attributes::ColorPointRY::Id,
                                              WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(Id, "color-point-rintensity", 0, UINT8_MAX,
                                                                             Attributes::ColorPointRIntensity::Id,
                                                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "color-point-gx", 0, UINT16_MAX, Attributes::ColorPointGX::Id,
                                              WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "color-point-gy", 0, UINT16_MAX, Attributes::ColorPointGY::Id,
                                              WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(Id, "color-point-gintensity", 0, UINT8_MAX,
                                                                             Attributes::ColorPointGIntensity::Id,
                                                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "color-point-bx", 0, UINT16_MAX, Attributes::ColorPointBX::Id,
                                              WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "color-point-by", 0, UINT16_MAX, Attributes::ColorPointBY::Id,
                                              WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(Id, "color-point-bintensity", 0, UINT8_MAX,
                                                                             Attributes::ColorPointBIntensity::Id,
                                                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "enhanced-current-hue", 0, UINT16_MAX, Attributes::EnhancedCurrentHue::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "enhanced-color-mode", 0, UINT8_MAX, Attributes::EnhancedColorMode::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "color-loop-active", 0, UINT8_MAX, Attributes::ColorLoopActive::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "color-loop-direction", 0, UINT8_MAX, Attributes::ColorLoopDirection::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "color-loop-time", 0, UINT16_MAX, Attributes::ColorLoopTime::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "color-loop-start-enhanced-hue", 0, UINT16_MAX,
                                              Attributes::ColorLoopStartEnhancedHue::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "color-loop-stored-enhanced-hue", 0, UINT16_MAX,
                                              Attributes::ColorLoopStoredEnhancedHue::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "color-capabilities", 0, UINT16_MAX, Attributes::ColorCapabilities::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "color-temp-physical-min-mireds", 0, UINT16_MAX,
                                              Attributes::ColorTempPhysicalMinMireds::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "color-temp-physical-max-mireds", 0, UINT16_MAX,
                                              Attributes::ColorTempPhysicalMaxMireds::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "couple-color-temp-to-level-min-mireds", 0, UINT16_MAX,
                                              Attributes::CoupleColorTempToLevelMinMireds::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint16_t>>>(
            Id, "start-up-color-temperature-mireds", 0, UINT16_MAX, Attributes::StartUpColorTemperatureMireds::Id,
            WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "current-hue", Attributes::CurrentHue::Id, credsIssuerConfig),               //
        make_unique<SubscribeAttribute>(Id, "current-saturation", Attributes::CurrentSaturation::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "remaining-time", Attributes::RemainingTime::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "current-x", Attributes::CurrentX::Id, credsIssuerConfig),                   //
        make_unique<SubscribeAttribute>(Id, "current-y", Attributes::CurrentY::Id, credsIssuerConfig),                   //
        make_unique<SubscribeAttribute>(Id, "drift-compensation", Attributes::DriftCompensation::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "compensation-text", Attributes::CompensationText::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "color-temperature-mireds", Attributes::ColorTemperatureMireds::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "color-mode", Attributes::ColorMode::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "options", Attributes::Options::Id, credsIssuerConfig),                             //
        make_unique<SubscribeAttribute>(Id, "number-of-primaries", Attributes::NumberOfPrimaries::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "primary1x", Attributes::Primary1X::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "primary1y", Attributes::Primary1Y::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "primary1intensity", Attributes::Primary1Intensity::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "primary2x", Attributes::Primary2X::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "primary2y", Attributes::Primary2Y::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "primary2intensity", Attributes::Primary2Intensity::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "primary3x", Attributes::Primary3X::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "primary3y", Attributes::Primary3Y::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "primary3intensity", Attributes::Primary3Intensity::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "primary4x", Attributes::Primary4X::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "primary4y", Attributes::Primary4Y::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "primary4intensity", Attributes::Primary4Intensity::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "primary5x", Attributes::Primary5X::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "primary5y", Attributes::Primary5Y::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "primary5intensity", Attributes::Primary5Intensity::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "primary6x", Attributes::Primary6X::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "primary6y", Attributes::Primary6Y::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "primary6intensity", Attributes::Primary6Intensity::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "white-point-x", Attributes::WhitePointX::Id, credsIssuerConfig),                   //
        make_unique<SubscribeAttribute>(Id, "white-point-y", Attributes::WhitePointY::Id, credsIssuerConfig),                   //
        make_unique<SubscribeAttribute>(Id, "color-point-rx", Attributes::ColorPointRX::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "color-point-ry", Attributes::ColorPointRY::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "color-point-rintensity", Attributes::ColorPointRIntensity::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "color-point-gx", Attributes::ColorPointGX::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "color-point-gy", Attributes::ColorPointGY::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "color-point-gintensity", Attributes::ColorPointGIntensity::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "color-point-bx", Attributes::ColorPointBX::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "color-point-by", Attributes::ColorPointBY::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "color-point-bintensity", Attributes::ColorPointBIntensity::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "enhanced-current-hue", Attributes::EnhancedCurrentHue::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "enhanced-color-mode", Attributes::EnhancedColorMode::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "color-loop-active", Attributes::ColorLoopActive::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "color-loop-direction", Attributes::ColorLoopDirection::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "color-loop-time", Attributes::ColorLoopTime::Id, credsIssuerConfig),               //
        make_unique<SubscribeAttribute>(Id, "color-loop-start-enhanced-hue", Attributes::ColorLoopStartEnhancedHue::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "color-loop-stored-enhanced-hue", Attributes::ColorLoopStoredEnhancedHue::Id,
                                        credsIssuerConfig),                                                              //
        make_unique<SubscribeAttribute>(Id, "color-capabilities", Attributes::ColorCapabilities::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "color-temp-physical-min-mireds", Attributes::ColorTempPhysicalMinMireds::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "color-temp-physical-max-mireds", Attributes::ColorTempPhysicalMaxMireds::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "couple-color-temp-to-level-min-mireds",
                                        Attributes::CoupleColorTempToLevelMinMireds::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "start-up-color-temperature-mireds", Attributes::StartUpColorTemperatureMireds::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterBallastConfiguration(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::BallastConfiguration;

    const char * clusterName = "BallastConfiguration";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                       //
        make_unique<ReadAttribute>(Id, "physical-min-level", Attributes::PhysicalMinLevel::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "physical-max-level", Attributes::PhysicalMaxLevel::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "ballast-status", Attributes::BallastStatus::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "min-level", Attributes::MinLevel::Id, credsIssuerConfig),                                //
        make_unique<ReadAttribute>(Id, "max-level", Attributes::MaxLevel::Id, credsIssuerConfig),                                //
        make_unique<ReadAttribute>(Id, "intrinsic-ballast-factor", Attributes::IntrinsicBallastFactor::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "ballast-factor-adjustment", Attributes::BallastFactorAdjustment::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "lamp-quantity", Attributes::LampQuantity::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "lamp-type", Attributes::LampType::Id, credsIssuerConfig),                                //
        make_unique<ReadAttribute>(Id, "lamp-manufacturer", Attributes::LampManufacturer::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "lamp-rated-hours", Attributes::LampRatedHours::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "lamp-burn-hours", Attributes::LampBurnHours::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "lamp-alarm-mode", Attributes::LampAlarmMode::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "lamp-burn-hours-trip-point", Attributes::LampBurnHoursTripPoint::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                              //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                            //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),                  //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                                    //
        make_unique<WriteAttribute<uint8_t>>(Id, "physical-min-level", 0, UINT8_MAX, Attributes::PhysicalMinLevel::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "physical-max-level", 0, UINT8_MAX, Attributes::PhysicalMaxLevel::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::BallastConfiguration::BallastStatusBitmap>>>(
            Id, "ballast-status", 0, UINT8_MAX, Attributes::BallastStatus::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "min-level", 0, UINT8_MAX, Attributes::MinLevel::Id, WriteCommandType::kWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "max-level", 0, UINT8_MAX, Attributes::MaxLevel::Id, WriteCommandType::kWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(Id, "intrinsic-ballast-factor", 0, UINT8_MAX,
                                                                             Attributes::IntrinsicBallastFactor::Id,
                                                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(Id, "ballast-factor-adjustment", 0, UINT8_MAX,
                                                                             Attributes::BallastFactorAdjustment::Id,
                                                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "lamp-quantity", 0, UINT8_MAX, Attributes::LampQuantity::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "lamp-type", Attributes::LampType::Id, WriteCommandType::kWrite,
                                                    credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "lamp-manufacturer", Attributes::LampManufacturer::Id,
                                                    WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(
            Id, "lamp-rated-hours", 0, UINT32_MAX, Attributes::LampRatedHours::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(
            Id, "lamp-burn-hours", 0, UINT32_MAX, Attributes::LampBurnHours::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::BallastConfiguration::LampAlarmModeBitmap>>>(
            Id, "lamp-alarm-mode", 0, UINT8_MAX, Attributes::LampAlarmMode::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(Id, "lamp-burn-hours-trip-point", 0, UINT32_MAX,
                                                                              Attributes::LampBurnHoursTripPoint::Id,
                                                                              WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                         //
        make_unique<SubscribeAttribute>(Id, "physical-min-level", Attributes::PhysicalMinLevel::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "physical-max-level", Attributes::PhysicalMaxLevel::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "ballast-status", Attributes::BallastStatus::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "min-level", Attributes::MinLevel::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "max-level", Attributes::MaxLevel::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "intrinsic-ballast-factor", Attributes::IntrinsicBallastFactor::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "ballast-factor-adjustment", Attributes::BallastFactorAdjustment::Id,
                                        credsIssuerConfig),                                                            //
        make_unique<SubscribeAttribute>(Id, "lamp-quantity", Attributes::LampQuantity::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "lamp-type", Attributes::LampType::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "lamp-manufacturer", Attributes::LampManufacturer::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "lamp-rated-hours", Attributes::LampRatedHours::Id, credsIssuerConfig),    //
        make_unique<SubscribeAttribute>(Id, "lamp-burn-hours", Attributes::LampBurnHours::Id, credsIssuerConfig),      //
        make_unique<SubscribeAttribute>(Id, "lamp-alarm-mode", Attributes::LampAlarmMode::Id, credsIssuerConfig),      //
        make_unique<SubscribeAttribute>(Id, "lamp-burn-hours-trip-point", Attributes::LampBurnHoursTripPoint::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterIlluminanceMeasurement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::IlluminanceMeasurement;

    const char * clusterName = "IlluminanceMeasurement";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "tolerance", Attributes::Tolerance::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "light-sensor-type", Attributes::LightSensorType::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint16_t>>>(Id, "measured-value", 0, UINT16_MAX,
                                                                              Attributes::MeasuredValue::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint16_t>>>(Id, "min-measured-value", 0, UINT16_MAX,
                                                                              Attributes::MinMeasuredValue::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint16_t>>>(Id, "max-measured-value", 0, UINT16_MAX,
                                                                              Attributes::MaxMeasuredValue::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "tolerance", 0, UINT16_MAX, Attributes::Tolerance::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<
            WriteAttribute<chip::app::DataModel::Nullable<chip::app::Clusters::IlluminanceMeasurement::LightSensorTypeEnum>>>(
            Id, "light-sensor-type", 0, UINT8_MAX, Attributes::LightSensorType::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "tolerance", Attributes::Tolerance::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "light-sensor-type", Attributes::LightSensorType::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterTemperatureMeasurement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::TemperatureMeasurement;

    const char * clusterName = "TemperatureMeasurement";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "tolerance", Attributes::Tolerance::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int16_t>>>(Id, "measured-value", INT16_MIN, INT16_MAX,
                                                                             Attributes::MeasuredValue::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int16_t>>>(Id, "min-measured-value", INT16_MIN, INT16_MAX,
                                                                             Attributes::MinMeasuredValue::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int16_t>>>(Id, "max-measured-value", INT16_MIN, INT16_MAX,
                                                                             Attributes::MaxMeasuredValue::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "tolerance", 0, UINT16_MAX, Attributes::Tolerance::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "tolerance", Attributes::Tolerance::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterPressureMeasurement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::PressureMeasurement;

    const char * clusterName = "PressureMeasurement";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "tolerance", Attributes::Tolerance::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "scaled-value", Attributes::ScaledValue::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "min-scaled-value", Attributes::MinScaledValue::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "max-scaled-value", Attributes::MaxScaledValue::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "scaled-tolerance", Attributes::ScaledTolerance::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "scale", Attributes::Scale::Id, credsIssuerConfig),                                 //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int16_t>>>(Id, "measured-value", INT16_MIN, INT16_MAX,
                                                                             Attributes::MeasuredValue::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int16_t>>>(Id, "min-measured-value", INT16_MIN, INT16_MAX,
                                                                             Attributes::MinMeasuredValue::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int16_t>>>(Id, "max-measured-value", INT16_MIN, INT16_MAX,
                                                                             Attributes::MaxMeasuredValue::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "tolerance", 0, UINT16_MAX, Attributes::Tolerance::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int16_t>>>(Id, "scaled-value", INT16_MIN, INT16_MAX,
                                                                             Attributes::ScaledValue::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int16_t>>>(Id, "min-scaled-value", INT16_MIN, INT16_MAX,
                                                                             Attributes::MinScaledValue::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int16_t>>>(Id, "max-scaled-value", INT16_MIN, INT16_MAX,
                                                                             Attributes::MaxScaledValue::Id,
                                                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "scaled-tolerance", 0, UINT16_MAX, Attributes::ScaledTolerance::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int8_t>>(Id, "scale", INT8_MIN, INT8_MAX, Attributes::Scale::Id, WriteCommandType::kForceWrite,
                                            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "tolerance", Attributes::Tolerance::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "scaled-value", Attributes::ScaledValue::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "min-scaled-value", Attributes::MinScaledValue::Id, credsIssuerConfig),             //
        make_unique<SubscribeAttribute>(Id, "max-scaled-value", Attributes::MaxScaledValue::Id, credsIssuerConfig),             //
        make_unique<SubscribeAttribute>(Id, "scaled-tolerance", Attributes::ScaledTolerance::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "scale", Attributes::Scale::Id, credsIssuerConfig),                                 //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterFlowMeasurement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::FlowMeasurement;

    const char * clusterName = "FlowMeasurement";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "tolerance", Attributes::Tolerance::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint16_t>>>(Id, "measured-value", 0, UINT16_MAX,
                                                                              Attributes::MeasuredValue::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint16_t>>>(Id, "min-measured-value", 0, UINT16_MAX,
                                                                              Attributes::MinMeasuredValue::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint16_t>>>(Id, "max-measured-value", 0, UINT16_MAX,
                                                                              Attributes::MaxMeasuredValue::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "tolerance", 0, UINT16_MAX, Attributes::Tolerance::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "tolerance", Attributes::Tolerance::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterRelativeHumidityMeasurement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::RelativeHumidityMeasurement;

    const char * clusterName = "RelativeHumidityMeasurement";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "tolerance", Attributes::Tolerance::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint16_t>>>(Id, "measured-value", 0, UINT16_MAX,
                                                                              Attributes::MeasuredValue::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint16_t>>>(Id, "min-measured-value", 0, UINT16_MAX,
                                                                              Attributes::MinMeasuredValue::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint16_t>>>(Id, "max-measured-value", 0, UINT16_MAX,
                                                                              Attributes::MaxMeasuredValue::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "tolerance", 0, UINT16_MAX, Attributes::Tolerance::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "tolerance", Attributes::Tolerance::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterOccupancySensing(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::OccupancySensing;

    const char * clusterName = "OccupancySensing";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                               //
        make_unique<ReadAttribute>(Id, "occupancy", Attributes::Occupancy::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "occupancy-sensor-type", Attributes::OccupancySensorType::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "occupancy-sensor-type-bitmap", Attributes::OccupancySensorTypeBitmap::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "piroccupied-to-unoccupied-delay", Attributes::PIROccupiedToUnoccupiedDelay::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "pirunoccupied-to-occupied-delay", Attributes::PIRUnoccupiedToOccupiedDelay::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "pirunoccupied-to-occupied-threshold", Attributes::PIRUnoccupiedToOccupiedThreshold::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "ultrasonic-occupied-to-unoccupied-delay",
                                   Attributes::UltrasonicOccupiedToUnoccupiedDelay::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "ultrasonic-unoccupied-to-occupied-delay",
                                   Attributes::UltrasonicUnoccupiedToOccupiedDelay::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "ultrasonic-unoccupied-to-occupied-threshold",
                                   Attributes::UltrasonicUnoccupiedToOccupiedThreshold::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "physical-contact-occupied-to-unoccupied-delay",
                                   Attributes::PhysicalContactOccupiedToUnoccupiedDelay::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "physical-contact-unoccupied-to-occupied-delay",
                                   Attributes::PhysicalContactUnoccupiedToOccupiedDelay::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "physical-contact-unoccupied-to-occupied-threshold",
                                   Attributes::PhysicalContactUnoccupiedToOccupiedThreshold::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::OccupancySensing::OccupancyBitmap>>>(
            Id, "occupancy", 0, UINT8_MAX, Attributes::Occupancy::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::OccupancySensing::OccupancySensorTypeEnum>>(
            Id, "occupancy-sensor-type", 0, UINT8_MAX, Attributes::OccupancySensorType::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::OccupancySensing::OccupancySensorTypeBitmap>>>(
            Id, "occupancy-sensor-type-bitmap", 0, UINT8_MAX, Attributes::OccupancySensorTypeBitmap::Id,
            WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "piroccupied-to-unoccupied-delay", 0, UINT16_MAX,
                                              Attributes::PIROccupiedToUnoccupiedDelay::Id, WriteCommandType::kWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "pirunoccupied-to-occupied-delay", 0, UINT16_MAX,
                                              Attributes::PIRUnoccupiedToOccupiedDelay::Id, WriteCommandType::kWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "pirunoccupied-to-occupied-threshold", 0, UINT8_MAX,
                                             Attributes::PIRUnoccupiedToOccupiedThreshold::Id, WriteCommandType::kWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "ultrasonic-occupied-to-unoccupied-delay", 0, UINT16_MAX,
                                              Attributes::UltrasonicOccupiedToUnoccupiedDelay::Id, WriteCommandType::kWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "ultrasonic-unoccupied-to-occupied-delay", 0, UINT16_MAX,
                                              Attributes::UltrasonicUnoccupiedToOccupiedDelay::Id, WriteCommandType::kWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "ultrasonic-unoccupied-to-occupied-threshold", 0, UINT8_MAX,
                                             Attributes::UltrasonicUnoccupiedToOccupiedThreshold::Id, WriteCommandType::kWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "physical-contact-occupied-to-unoccupied-delay", 0, UINT16_MAX,
                                              Attributes::PhysicalContactOccupiedToUnoccupiedDelay::Id, WriteCommandType::kWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "physical-contact-unoccupied-to-occupied-delay", 0, UINT16_MAX,
                                              Attributes::PhysicalContactUnoccupiedToOccupiedDelay::Id, WriteCommandType::kWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "physical-contact-unoccupied-to-occupied-threshold", 0, UINT8_MAX,
                                             Attributes::PhysicalContactUnoccupiedToOccupiedThreshold::Id, WriteCommandType::kWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                              //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                               //
        make_unique<SubscribeAttribute>(Id, "occupancy", Attributes::Occupancy::Id, credsIssuerConfig),                       //
        make_unique<SubscribeAttribute>(Id, "occupancy-sensor-type", Attributes::OccupancySensorType::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "occupancy-sensor-type-bitmap", Attributes::OccupancySensorTypeBitmap::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "piroccupied-to-unoccupied-delay", Attributes::PIROccupiedToUnoccupiedDelay::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "pirunoccupied-to-occupied-delay", Attributes::PIRUnoccupiedToOccupiedDelay::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "pirunoccupied-to-occupied-threshold", Attributes::PIRUnoccupiedToOccupiedThreshold::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "ultrasonic-occupied-to-unoccupied-delay",
                                        Attributes::UltrasonicOccupiedToUnoccupiedDelay::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "ultrasonic-unoccupied-to-occupied-delay",
                                        Attributes::UltrasonicUnoccupiedToOccupiedDelay::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "ultrasonic-unoccupied-to-occupied-threshold",
                                        Attributes::UltrasonicUnoccupiedToOccupiedThreshold::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "physical-contact-occupied-to-unoccupied-delay",
                                        Attributes::PhysicalContactOccupiedToUnoccupiedDelay::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "physical-contact-unoccupied-to-occupied-delay",
                                        Attributes::PhysicalContactUnoccupiedToOccupiedDelay::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "physical-contact-unoccupied-to-occupied-threshold",
                                        Attributes::PhysicalContactUnoccupiedToOccupiedThreshold::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterCarbonMonoxideConcentrationMeasurement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::CarbonMonoxideConcentrationMeasurement;

    const char * clusterName = "CarbonMonoxideConcentrationMeasurement";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                        //
        make_unique<ReadAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "peak-measured-value", Attributes::PeakMeasuredValue::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "peak-measured-value-window", Attributes::PeakMeasuredValueWindow::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "average-measured-value", Attributes::AverageMeasuredValue::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "average-measured-value-window", Attributes::AverageMeasuredValueWindow::Id,
                                   credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "uncertainty", Attributes::Uncertainty::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "measurement-unit", Attributes::MeasurementUnit::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "measurement-medium", Attributes::MeasurementMedium::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "level-value", Attributes::LevelValue::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::MeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "min-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::MinMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "max-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::MaxMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "peak-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::PeakMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "peak-measured-value-window", 0, UINT32_MAX,
                                              Attributes::PeakMeasuredValueWindow::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "average-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::AverageMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "average-measured-value-window", 0, UINT32_MAX,
                                              Attributes::AverageMeasuredValueWindow::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<float>>(Id, "uncertainty", -std::numeric_limits<float>::infinity(),
                                           std::numeric_limits<float>::infinity(), Attributes::Uncertainty::Id,
                                           WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::CarbonMonoxideConcentrationMeasurement::MeasurementUnitEnum>>(
            Id, "measurement-unit", 0, UINT8_MAX, Attributes::MeasurementUnit::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::CarbonMonoxideConcentrationMeasurement::MeasurementMediumEnum>>(
            Id, "measurement-medium", 0, UINT8_MAX, Attributes::MeasurementMedium::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::CarbonMonoxideConcentrationMeasurement::LevelValueEnum>>(
            Id, "level-value", 0, UINT8_MAX, Attributes::LevelValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                           //
        make_unique<SubscribeAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "peak-measured-value", Attributes::PeakMeasuredValue::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "peak-measured-value-window", Attributes::PeakMeasuredValueWindow::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "average-measured-value", Attributes::AverageMeasuredValue::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "average-measured-value-window", Attributes::AverageMeasuredValueWindow::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "uncertainty", Attributes::Uncertainty::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "measurement-unit", Attributes::MeasurementUnit::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "measurement-medium", Attributes::MeasurementMedium::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "level-value", Attributes::LevelValue::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterCarbonDioxideConcentrationMeasurement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::CarbonDioxideConcentrationMeasurement;

    const char * clusterName = "CarbonDioxideConcentrationMeasurement";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                        //
        make_unique<ReadAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "peak-measured-value", Attributes::PeakMeasuredValue::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "peak-measured-value-window", Attributes::PeakMeasuredValueWindow::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "average-measured-value", Attributes::AverageMeasuredValue::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "average-measured-value-window", Attributes::AverageMeasuredValueWindow::Id,
                                   credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "uncertainty", Attributes::Uncertainty::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "measurement-unit", Attributes::MeasurementUnit::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "measurement-medium", Attributes::MeasurementMedium::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "level-value", Attributes::LevelValue::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::MeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "min-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::MinMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "max-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::MaxMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "peak-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::PeakMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "peak-measured-value-window", 0, UINT32_MAX,
                                              Attributes::PeakMeasuredValueWindow::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "average-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::AverageMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "average-measured-value-window", 0, UINT32_MAX,
                                              Attributes::AverageMeasuredValueWindow::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<float>>(Id, "uncertainty", -std::numeric_limits<float>::infinity(),
                                           std::numeric_limits<float>::infinity(), Attributes::Uncertainty::Id,
                                           WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::CarbonDioxideConcentrationMeasurement::MeasurementUnitEnum>>(
            Id, "measurement-unit", 0, UINT8_MAX, Attributes::MeasurementUnit::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::CarbonDioxideConcentrationMeasurement::MeasurementMediumEnum>>(
            Id, "measurement-medium", 0, UINT8_MAX, Attributes::MeasurementMedium::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::CarbonDioxideConcentrationMeasurement::LevelValueEnum>>(
            Id, "level-value", 0, UINT8_MAX, Attributes::LevelValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                           //
        make_unique<SubscribeAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "peak-measured-value", Attributes::PeakMeasuredValue::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "peak-measured-value-window", Attributes::PeakMeasuredValueWindow::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "average-measured-value", Attributes::AverageMeasuredValue::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "average-measured-value-window", Attributes::AverageMeasuredValueWindow::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "uncertainty", Attributes::Uncertainty::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "measurement-unit", Attributes::MeasurementUnit::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "measurement-medium", Attributes::MeasurementMedium::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "level-value", Attributes::LevelValue::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterNitrogenDioxideConcentrationMeasurement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::NitrogenDioxideConcentrationMeasurement;

    const char * clusterName = "NitrogenDioxideConcentrationMeasurement";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                        //
        make_unique<ReadAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "peak-measured-value", Attributes::PeakMeasuredValue::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "peak-measured-value-window", Attributes::PeakMeasuredValueWindow::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "average-measured-value", Attributes::AverageMeasuredValue::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "average-measured-value-window", Attributes::AverageMeasuredValueWindow::Id,
                                   credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "uncertainty", Attributes::Uncertainty::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "measurement-unit", Attributes::MeasurementUnit::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "measurement-medium", Attributes::MeasurementMedium::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "level-value", Attributes::LevelValue::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::MeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "min-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::MinMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "max-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::MaxMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "peak-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::PeakMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "peak-measured-value-window", 0, UINT32_MAX,
                                              Attributes::PeakMeasuredValueWindow::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "average-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::AverageMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "average-measured-value-window", 0, UINT32_MAX,
                                              Attributes::AverageMeasuredValueWindow::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<float>>(Id, "uncertainty", -std::numeric_limits<float>::infinity(),
                                           std::numeric_limits<float>::infinity(), Attributes::Uncertainty::Id,
                                           WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::NitrogenDioxideConcentrationMeasurement::MeasurementUnitEnum>>(
            Id, "measurement-unit", 0, UINT8_MAX, Attributes::MeasurementUnit::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::NitrogenDioxideConcentrationMeasurement::MeasurementMediumEnum>>(
            Id, "measurement-medium", 0, UINT8_MAX, Attributes::MeasurementMedium::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::NitrogenDioxideConcentrationMeasurement::LevelValueEnum>>(
            Id, "level-value", 0, UINT8_MAX, Attributes::LevelValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                           //
        make_unique<SubscribeAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "peak-measured-value", Attributes::PeakMeasuredValue::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "peak-measured-value-window", Attributes::PeakMeasuredValueWindow::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "average-measured-value", Attributes::AverageMeasuredValue::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "average-measured-value-window", Attributes::AverageMeasuredValueWindow::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "uncertainty", Attributes::Uncertainty::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "measurement-unit", Attributes::MeasurementUnit::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "measurement-medium", Attributes::MeasurementMedium::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "level-value", Attributes::LevelValue::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterOzoneConcentrationMeasurement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::OzoneConcentrationMeasurement;

    const char * clusterName = "OzoneConcentrationMeasurement";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                        //
        make_unique<ReadAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "peak-measured-value", Attributes::PeakMeasuredValue::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "peak-measured-value-window", Attributes::PeakMeasuredValueWindow::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "average-measured-value", Attributes::AverageMeasuredValue::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "average-measured-value-window", Attributes::AverageMeasuredValueWindow::Id,
                                   credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "uncertainty", Attributes::Uncertainty::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "measurement-unit", Attributes::MeasurementUnit::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "measurement-medium", Attributes::MeasurementMedium::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "level-value", Attributes::LevelValue::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::MeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "min-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::MinMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "max-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::MaxMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "peak-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::PeakMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "peak-measured-value-window", 0, UINT32_MAX,
                                              Attributes::PeakMeasuredValueWindow::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "average-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::AverageMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "average-measured-value-window", 0, UINT32_MAX,
                                              Attributes::AverageMeasuredValueWindow::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<float>>(Id, "uncertainty", -std::numeric_limits<float>::infinity(),
                                           std::numeric_limits<float>::infinity(), Attributes::Uncertainty::Id,
                                           WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::OzoneConcentrationMeasurement::MeasurementUnitEnum>>(
            Id, "measurement-unit", 0, UINT8_MAX, Attributes::MeasurementUnit::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::OzoneConcentrationMeasurement::MeasurementMediumEnum>>(
            Id, "measurement-medium", 0, UINT8_MAX, Attributes::MeasurementMedium::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::OzoneConcentrationMeasurement::LevelValueEnum>>(
            Id, "level-value", 0, UINT8_MAX, Attributes::LevelValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                           //
        make_unique<SubscribeAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "peak-measured-value", Attributes::PeakMeasuredValue::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "peak-measured-value-window", Attributes::PeakMeasuredValueWindow::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "average-measured-value", Attributes::AverageMeasuredValue::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "average-measured-value-window", Attributes::AverageMeasuredValueWindow::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "uncertainty", Attributes::Uncertainty::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "measurement-unit", Attributes::MeasurementUnit::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "measurement-medium", Attributes::MeasurementMedium::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "level-value", Attributes::LevelValue::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterPm25ConcentrationMeasurement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::Pm25ConcentrationMeasurement;

    const char * clusterName = "Pm25ConcentrationMeasurement";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                        //
        make_unique<ReadAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "peak-measured-value", Attributes::PeakMeasuredValue::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "peak-measured-value-window", Attributes::PeakMeasuredValueWindow::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "average-measured-value", Attributes::AverageMeasuredValue::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "average-measured-value-window", Attributes::AverageMeasuredValueWindow::Id,
                                   credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "uncertainty", Attributes::Uncertainty::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "measurement-unit", Attributes::MeasurementUnit::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "measurement-medium", Attributes::MeasurementMedium::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "level-value", Attributes::LevelValue::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::MeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "min-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::MinMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "max-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::MaxMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "peak-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::PeakMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "peak-measured-value-window", 0, UINT32_MAX,
                                              Attributes::PeakMeasuredValueWindow::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "average-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::AverageMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "average-measured-value-window", 0, UINT32_MAX,
                                              Attributes::AverageMeasuredValueWindow::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<float>>(Id, "uncertainty", -std::numeric_limits<float>::infinity(),
                                           std::numeric_limits<float>::infinity(), Attributes::Uncertainty::Id,
                                           WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::Pm25ConcentrationMeasurement::MeasurementUnitEnum>>(
            Id, "measurement-unit", 0, UINT8_MAX, Attributes::MeasurementUnit::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::Pm25ConcentrationMeasurement::MeasurementMediumEnum>>(
            Id, "measurement-medium", 0, UINT8_MAX, Attributes::MeasurementMedium::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::Pm25ConcentrationMeasurement::LevelValueEnum>>(
            Id, "level-value", 0, UINT8_MAX, Attributes::LevelValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                           //
        make_unique<SubscribeAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "peak-measured-value", Attributes::PeakMeasuredValue::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "peak-measured-value-window", Attributes::PeakMeasuredValueWindow::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "average-measured-value", Attributes::AverageMeasuredValue::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "average-measured-value-window", Attributes::AverageMeasuredValueWindow::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "uncertainty", Attributes::Uncertainty::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "measurement-unit", Attributes::MeasurementUnit::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "measurement-medium", Attributes::MeasurementMedium::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "level-value", Attributes::LevelValue::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterFormaldehydeConcentrationMeasurement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::FormaldehydeConcentrationMeasurement;

    const char * clusterName = "FormaldehydeConcentrationMeasurement";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                        //
        make_unique<ReadAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "peak-measured-value", Attributes::PeakMeasuredValue::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "peak-measured-value-window", Attributes::PeakMeasuredValueWindow::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "average-measured-value", Attributes::AverageMeasuredValue::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "average-measured-value-window", Attributes::AverageMeasuredValueWindow::Id,
                                   credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "uncertainty", Attributes::Uncertainty::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "measurement-unit", Attributes::MeasurementUnit::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "measurement-medium", Attributes::MeasurementMedium::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "level-value", Attributes::LevelValue::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::MeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "min-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::MinMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "max-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::MaxMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "peak-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::PeakMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "peak-measured-value-window", 0, UINT32_MAX,
                                              Attributes::PeakMeasuredValueWindow::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "average-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::AverageMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "average-measured-value-window", 0, UINT32_MAX,
                                              Attributes::AverageMeasuredValueWindow::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<float>>(Id, "uncertainty", -std::numeric_limits<float>::infinity(),
                                           std::numeric_limits<float>::infinity(), Attributes::Uncertainty::Id,
                                           WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::FormaldehydeConcentrationMeasurement::MeasurementUnitEnum>>(
            Id, "measurement-unit", 0, UINT8_MAX, Attributes::MeasurementUnit::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::FormaldehydeConcentrationMeasurement::MeasurementMediumEnum>>(
            Id, "measurement-medium", 0, UINT8_MAX, Attributes::MeasurementMedium::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::FormaldehydeConcentrationMeasurement::LevelValueEnum>>(
            Id, "level-value", 0, UINT8_MAX, Attributes::LevelValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                           //
        make_unique<SubscribeAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "peak-measured-value", Attributes::PeakMeasuredValue::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "peak-measured-value-window", Attributes::PeakMeasuredValueWindow::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "average-measured-value", Attributes::AverageMeasuredValue::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "average-measured-value-window", Attributes::AverageMeasuredValueWindow::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "uncertainty", Attributes::Uncertainty::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "measurement-unit", Attributes::MeasurementUnit::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "measurement-medium", Attributes::MeasurementMedium::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "level-value", Attributes::LevelValue::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterPm1ConcentrationMeasurement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::Pm1ConcentrationMeasurement;

    const char * clusterName = "Pm1ConcentrationMeasurement";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                        //
        make_unique<ReadAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "peak-measured-value", Attributes::PeakMeasuredValue::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "peak-measured-value-window", Attributes::PeakMeasuredValueWindow::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "average-measured-value", Attributes::AverageMeasuredValue::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "average-measured-value-window", Attributes::AverageMeasuredValueWindow::Id,
                                   credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "uncertainty", Attributes::Uncertainty::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "measurement-unit", Attributes::MeasurementUnit::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "measurement-medium", Attributes::MeasurementMedium::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "level-value", Attributes::LevelValue::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::MeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "min-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::MinMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "max-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::MaxMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "peak-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::PeakMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "peak-measured-value-window", 0, UINT32_MAX,
                                              Attributes::PeakMeasuredValueWindow::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "average-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::AverageMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "average-measured-value-window", 0, UINT32_MAX,
                                              Attributes::AverageMeasuredValueWindow::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<float>>(Id, "uncertainty", -std::numeric_limits<float>::infinity(),
                                           std::numeric_limits<float>::infinity(), Attributes::Uncertainty::Id,
                                           WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::Pm1ConcentrationMeasurement::MeasurementUnitEnum>>(
            Id, "measurement-unit", 0, UINT8_MAX, Attributes::MeasurementUnit::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::Pm1ConcentrationMeasurement::MeasurementMediumEnum>>(
            Id, "measurement-medium", 0, UINT8_MAX, Attributes::MeasurementMedium::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::Pm1ConcentrationMeasurement::LevelValueEnum>>(
            Id, "level-value", 0, UINT8_MAX, Attributes::LevelValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                           //
        make_unique<SubscribeAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "peak-measured-value", Attributes::PeakMeasuredValue::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "peak-measured-value-window", Attributes::PeakMeasuredValueWindow::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "average-measured-value", Attributes::AverageMeasuredValue::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "average-measured-value-window", Attributes::AverageMeasuredValueWindow::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "uncertainty", Attributes::Uncertainty::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "measurement-unit", Attributes::MeasurementUnit::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "measurement-medium", Attributes::MeasurementMedium::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "level-value", Attributes::LevelValue::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterPm10ConcentrationMeasurement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::Pm10ConcentrationMeasurement;

    const char * clusterName = "Pm10ConcentrationMeasurement";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                        //
        make_unique<ReadAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "peak-measured-value", Attributes::PeakMeasuredValue::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "peak-measured-value-window", Attributes::PeakMeasuredValueWindow::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "average-measured-value", Attributes::AverageMeasuredValue::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "average-measured-value-window", Attributes::AverageMeasuredValueWindow::Id,
                                   credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "uncertainty", Attributes::Uncertainty::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "measurement-unit", Attributes::MeasurementUnit::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "measurement-medium", Attributes::MeasurementMedium::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "level-value", Attributes::LevelValue::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::MeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "min-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::MinMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "max-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::MaxMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "peak-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::PeakMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "peak-measured-value-window", 0, UINT32_MAX,
                                              Attributes::PeakMeasuredValueWindow::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "average-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::AverageMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "average-measured-value-window", 0, UINT32_MAX,
                                              Attributes::AverageMeasuredValueWindow::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<float>>(Id, "uncertainty", -std::numeric_limits<float>::infinity(),
                                           std::numeric_limits<float>::infinity(), Attributes::Uncertainty::Id,
                                           WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::Pm10ConcentrationMeasurement::MeasurementUnitEnum>>(
            Id, "measurement-unit", 0, UINT8_MAX, Attributes::MeasurementUnit::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::Pm10ConcentrationMeasurement::MeasurementMediumEnum>>(
            Id, "measurement-medium", 0, UINT8_MAX, Attributes::MeasurementMedium::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::Pm10ConcentrationMeasurement::LevelValueEnum>>(
            Id, "level-value", 0, UINT8_MAX, Attributes::LevelValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                           //
        make_unique<SubscribeAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "peak-measured-value", Attributes::PeakMeasuredValue::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "peak-measured-value-window", Attributes::PeakMeasuredValueWindow::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "average-measured-value", Attributes::AverageMeasuredValue::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "average-measured-value-window", Attributes::AverageMeasuredValueWindow::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "uncertainty", Attributes::Uncertainty::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "measurement-unit", Attributes::MeasurementUnit::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "measurement-medium", Attributes::MeasurementMedium::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "level-value", Attributes::LevelValue::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterTotalVolatileOrganicCompoundsConcentrationMeasurement(Commands & commands,
                                                                          CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement;

    const char * clusterName = "TotalVolatileOrganicCompoundsConcentrationMeasurement";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                        //
        make_unique<ReadAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "peak-measured-value", Attributes::PeakMeasuredValue::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "peak-measured-value-window", Attributes::PeakMeasuredValueWindow::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "average-measured-value", Attributes::AverageMeasuredValue::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "average-measured-value-window", Attributes::AverageMeasuredValueWindow::Id,
                                   credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "uncertainty", Attributes::Uncertainty::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "measurement-unit", Attributes::MeasurementUnit::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "measurement-medium", Attributes::MeasurementMedium::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "level-value", Attributes::LevelValue::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::MeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "min-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::MinMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "max-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::MaxMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "peak-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::PeakMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "peak-measured-value-window", 0, UINT32_MAX,
                                              Attributes::PeakMeasuredValueWindow::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "average-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::AverageMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "average-measured-value-window", 0, UINT32_MAX,
                                              Attributes::AverageMeasuredValueWindow::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<float>>(Id, "uncertainty", -std::numeric_limits<float>::infinity(),
                                           std::numeric_limits<float>::infinity(), Attributes::Uncertainty::Id,
                                           WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<
            WriteAttribute<chip::app::Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::MeasurementUnitEnum>>(
            Id, "measurement-unit", 0, UINT8_MAX, Attributes::MeasurementUnit::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<
            WriteAttribute<chip::app::Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::MeasurementMediumEnum>>(
            Id, "measurement-medium", 0, UINT8_MAX, Attributes::MeasurementMedium::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::TotalVolatileOrganicCompoundsConcentrationMeasurement::LevelValueEnum>>(
            Id, "level-value", 0, UINT8_MAX, Attributes::LevelValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                           //
        make_unique<SubscribeAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "peak-measured-value", Attributes::PeakMeasuredValue::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "peak-measured-value-window", Attributes::PeakMeasuredValueWindow::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "average-measured-value", Attributes::AverageMeasuredValue::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "average-measured-value-window", Attributes::AverageMeasuredValueWindow::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "uncertainty", Attributes::Uncertainty::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "measurement-unit", Attributes::MeasurementUnit::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "measurement-medium", Attributes::MeasurementMedium::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "level-value", Attributes::LevelValue::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterRadonConcentrationMeasurement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::RadonConcentrationMeasurement;

    const char * clusterName = "RadonConcentrationMeasurement";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                        //
        make_unique<ReadAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "peak-measured-value", Attributes::PeakMeasuredValue::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "peak-measured-value-window", Attributes::PeakMeasuredValueWindow::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "average-measured-value", Attributes::AverageMeasuredValue::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "average-measured-value-window", Attributes::AverageMeasuredValueWindow::Id,
                                   credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "uncertainty", Attributes::Uncertainty::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "measurement-unit", Attributes::MeasurementUnit::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "measurement-medium", Attributes::MeasurementMedium::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "level-value", Attributes::LevelValue::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::MeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "min-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::MinMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "max-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::MaxMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "peak-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::PeakMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "peak-measured-value-window", 0, UINT32_MAX,
                                              Attributes::PeakMeasuredValueWindow::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "average-measured-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::AverageMeasuredValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "average-measured-value-window", 0, UINT32_MAX,
                                              Attributes::AverageMeasuredValueWindow::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<float>>(Id, "uncertainty", -std::numeric_limits<float>::infinity(),
                                           std::numeric_limits<float>::infinity(), Attributes::Uncertainty::Id,
                                           WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::RadonConcentrationMeasurement::MeasurementUnitEnum>>(
            Id, "measurement-unit", 0, UINT8_MAX, Attributes::MeasurementUnit::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::RadonConcentrationMeasurement::MeasurementMediumEnum>>(
            Id, "measurement-medium", 0, UINT8_MAX, Attributes::MeasurementMedium::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::RadonConcentrationMeasurement::LevelValueEnum>>(
            Id, "level-value", 0, UINT8_MAX, Attributes::LevelValue::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                           //
        make_unique<SubscribeAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "peak-measured-value", Attributes::PeakMeasuredValue::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "peak-measured-value-window", Attributes::PeakMeasuredValueWindow::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "average-measured-value", Attributes::AverageMeasuredValue::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "average-measured-value-window", Attributes::AverageMeasuredValueWindow::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "uncertainty", Attributes::Uncertainty::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "measurement-unit", Attributes::MeasurementUnit::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "measurement-medium", Attributes::MeasurementMedium::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "level-value", Attributes::LevelValue::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterWakeOnLan(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::WakeOnLan;

    const char * clusterName = "WakeOnLan";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "macaddress", Attributes::MACAddress::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "link-local-address", Attributes::LinkLocalAddress::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "macaddress", Attributes::MACAddress::Id, WriteCommandType::kForceWrite,
                                                    credsIssuerConfig), //
        make_unique<WriteAttribute<chip::ByteSpan>>(Id, "link-local-address", Attributes::LinkLocalAddress::Id,
                                                    WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "macaddress", Attributes::MACAddress::Id, credsIssuerConfig),                       //
        make_unique<SubscribeAttribute>(Id, "link-local-address", Attributes::LinkLocalAddress::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterChannel(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::Channel;

    const char * clusterName = "Channel";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),           //
        make_unique<ChannelChangeChannel>(credsIssuerConfig),         //
        make_unique<ChannelChangeChannelByNumber>(credsIssuerConfig), //
        make_unique<ChannelSkipChannel>(credsIssuerConfig),           //
        make_unique<ChannelGetProgramGuide>(credsIssuerConfig),       //
        make_unique<ChannelRecordProgram>(credsIssuerConfig),         //
        make_unique<ChannelCancelRecordProgram>(credsIssuerConfig),   //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "channel-list", Attributes::ChannelList::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "lineup", Attributes::Lineup::Id, credsIssuerConfig),                               //
        make_unique<ReadAttribute>(Id, "current-channel", Attributes::CurrentChannel::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::Channel::Structs::ChannelInfoStruct::Type>>>(
            Id, "channel-list", Attributes::ChannelList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<
            WriteAttributeAsComplex<chip::app::DataModel::Nullable<chip::app::Clusters::Channel::Structs::LineupInfoStruct::Type>>>(
            Id, "lineup", Attributes::Lineup::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::Nullable<chip::app::Clusters::Channel::Structs::ChannelInfoStruct::Type>>>(
            Id, "current-channel", Attributes::CurrentChannel::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "channel-list", Attributes::ChannelList::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "lineup", Attributes::Lineup::Id, credsIssuerConfig),                               //
        make_unique<SubscribeAttribute>(Id, "current-channel", Attributes::CurrentChannel::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterTargetNavigator(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::TargetNavigator;

    const char * clusterName = "TargetNavigator";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),            //
        make_unique<TargetNavigatorNavigateTarget>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "target-list", Attributes::TargetList::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "current-target", Attributes::CurrentTarget::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::TargetNavigator::Structs::TargetInfoStruct::Type>>>(
            Id, "target-list", Attributes::TargetList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "current-target", 0, UINT8_MAX, Attributes::CurrentTarget::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "target-list", Attributes::TargetList::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "current-target", Attributes::CurrentTarget::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                   //
        make_unique<ReadEvent>(Id, "target-updated", Events::TargetUpdated::Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                              //
        make_unique<SubscribeEvent>(Id, "target-updated", Events::TargetUpdated::Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterMediaPlayback(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::MediaPlayback;

    const char * clusterName = "MediaPlayback";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),               //
        make_unique<MediaPlaybackPlay>(credsIssuerConfig),                //
        make_unique<MediaPlaybackPause>(credsIssuerConfig),               //
        make_unique<MediaPlaybackStop>(credsIssuerConfig),                //
        make_unique<MediaPlaybackStartOver>(credsIssuerConfig),           //
        make_unique<MediaPlaybackPrevious>(credsIssuerConfig),            //
        make_unique<MediaPlaybackNext>(credsIssuerConfig),                //
        make_unique<MediaPlaybackRewind>(credsIssuerConfig),              //
        make_unique<MediaPlaybackFastForward>(credsIssuerConfig),         //
        make_unique<MediaPlaybackSkipForward>(credsIssuerConfig),         //
        make_unique<MediaPlaybackSkipBackward>(credsIssuerConfig),        //
        make_unique<MediaPlaybackSeek>(credsIssuerConfig),                //
        make_unique<MediaPlaybackActivateAudioTrack>(credsIssuerConfig),  //
        make_unique<MediaPlaybackActivateTextTrack>(credsIssuerConfig),   //
        make_unique<MediaPlaybackDeactivateTextTrack>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "current-state", Attributes::CurrentState::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "start-time", Attributes::StartTime::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "duration", Attributes::Duration::Id, credsIssuerConfig),                           //
        make_unique<ReadAttribute>(Id, "sampled-position", Attributes::SampledPosition::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "playback-speed", Attributes::PlaybackSpeed::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "seek-range-end", Attributes::SeekRangeEnd::Id, credsIssuerConfig),                 //
        make_unique<ReadAttribute>(Id, "seek-range-start", Attributes::SeekRangeStart::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "active-audio-track", Attributes::ActiveAudioTrack::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "available-audio-tracks", Attributes::AvailableAudioTracks::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "active-text-track", Attributes::ActiveTextTrack::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "available-text-tracks", Attributes::AvailableTextTracks::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::app::Clusters::MediaPlayback::PlaybackStateEnum>>(
            Id, "current-state", 0, UINT8_MAX, Attributes::CurrentState::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint64_t>>>(
            Id, "start-time", 0, UINT64_MAX, Attributes::StartTime::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint64_t>>>(
            Id, "duration", 0, UINT64_MAX, Attributes::Duration::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::Nullable<chip::app::Clusters::MediaPlayback::Structs::PlaybackPositionStruct::Type>>>(
            Id, "sampled-position", Attributes::SampledPosition::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<float>>(Id, "playback-speed", -std::numeric_limits<float>::infinity(),
                                           std::numeric_limits<float>::infinity(), Attributes::PlaybackSpeed::Id,
                                           WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint64_t>>>(
            Id, "seek-range-end", 0, UINT64_MAX, Attributes::SeekRangeEnd::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint64_t>>>(Id, "seek-range-start", 0, UINT64_MAX,
                                                                              Attributes::SeekRangeStart::Id,
                                                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::Nullable<chip::app::Clusters::MediaPlayback::Structs::TrackStruct::Type>>>(
            Id, "active-audio-track", Attributes::ActiveAudioTrack::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::Nullable<
            chip::app::DataModel::List<const chip::app::Clusters::MediaPlayback::Structs::TrackStruct::Type>>>>(
            Id, "available-audio-tracks", Attributes::AvailableAudioTracks::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::Nullable<chip::app::Clusters::MediaPlayback::Structs::TrackStruct::Type>>>(
            Id, "active-text-track", Attributes::ActiveTextTrack::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::Nullable<
            chip::app::DataModel::List<const chip::app::Clusters::MediaPlayback::Structs::TrackStruct::Type>>>>(
            Id, "available-text-tracks", Attributes::AvailableTextTracks::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "current-state", Attributes::CurrentState::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "start-time", Attributes::StartTime::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "duration", Attributes::Duration::Id, credsIssuerConfig),                           //
        make_unique<SubscribeAttribute>(Id, "sampled-position", Attributes::SampledPosition::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "playback-speed", Attributes::PlaybackSpeed::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "seek-range-end", Attributes::SeekRangeEnd::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "seek-range-start", Attributes::SeekRangeStart::Id, credsIssuerConfig),             //
        make_unique<SubscribeAttribute>(Id, "active-audio-track", Attributes::ActiveAudioTrack::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "available-audio-tracks", Attributes::AvailableAudioTracks::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "active-text-track", Attributes::ActiveTextTrack::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "available-text-tracks", Attributes::AvailableTextTracks::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                 //
        make_unique<ReadEvent>(Id, "state-changed", Events::StateChanged::Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                            //
        make_unique<SubscribeEvent>(Id, "state-changed", Events::StateChanged::Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterMediaInput(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::MediaInput;

    const char * clusterName = "MediaInput";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),        //
        make_unique<MediaInputSelectInput>(credsIssuerConfig),     //
        make_unique<MediaInputShowInputStatus>(credsIssuerConfig), //
        make_unique<MediaInputHideInputStatus>(credsIssuerConfig), //
        make_unique<MediaInputRenameInput>(credsIssuerConfig),     //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "input-list", Attributes::InputList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "current-input", Attributes::CurrentInput::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::MediaInput::Structs::InputInfoStruct::Type>>>(
            Id, "input-list", Attributes::InputList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "current-input", 0, UINT8_MAX, Attributes::CurrentInput::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "input-list", Attributes::InputList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "current-input", Attributes::CurrentInput::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterLowPower(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::LowPower;

    const char * clusterName = "LowPower";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        make_unique<LowPowerSleep>(credsIssuerConfig),      //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterKeypadInput(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::KeypadInput;

    const char * clusterName = "KeypadInput";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        make_unique<KeypadInputSendKey>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterContentLauncher(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::ContentLauncher;

    const char * clusterName = "ContentLauncher";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),           //
        make_unique<ContentLauncherLaunchContent>(credsIssuerConfig), //
        make_unique<ContentLauncherLaunchURL>(credsIssuerConfig),     //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                //
        make_unique<ReadAttribute>(Id, "accept-header", Attributes::AcceptHeader::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "supported-streaming-protocols", Attributes::SupportedStreamingProtocols::Id,
                                   credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CharSpan>>>(
            Id, "accept-header", Attributes::AcceptHeader::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::ContentLauncher::SupportedProtocolsBitmap>>>(
            Id, "supported-streaming-protocols", 0, UINT32_MAX, Attributes::SupportedStreamingProtocols::Id,
            WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),               //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                //
        make_unique<SubscribeAttribute>(Id, "accept-header", Attributes::AcceptHeader::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "supported-streaming-protocols", Attributes::SupportedStreamingProtocols::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterAudioOutput(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::AudioOutput;

    const char * clusterName = "AudioOutput";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),      //
        make_unique<AudioOutputSelectOutput>(credsIssuerConfig), //
        make_unique<AudioOutputRenameOutput>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "output-list", Attributes::OutputList::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "current-output", Attributes::CurrentOutput::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::AudioOutput::Structs::OutputInfoStruct::Type>>>(
            Id, "output-list", Attributes::OutputList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "current-output", 0, UINT8_MAX, Attributes::CurrentOutput::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "output-list", Attributes::OutputList::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "current-output", Attributes::CurrentOutput::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterApplicationLauncher(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::ApplicationLauncher;

    const char * clusterName = "ApplicationLauncher";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),           //
        make_unique<ApplicationLauncherLaunchApp>(credsIssuerConfig), //
        make_unique<ApplicationLauncherStopApp>(credsIssuerConfig),   //
        make_unique<ApplicationLauncherHideApp>(credsIssuerConfig),   //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "catalog-list", Attributes::CatalogList::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "current-app", Attributes::CurrentApp::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const uint16_t>>>(
            Id, "catalog-list", Attributes::CatalogList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::Nullable<chip::app::Clusters::ApplicationLauncher::Structs::ApplicationEPStruct::Type>>>(
            Id, "current-app", Attributes::CurrentApp::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "catalog-list", Attributes::CatalogList::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "current-app", Attributes::CurrentApp::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterApplicationBasic(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::ApplicationBasic;

    const char * clusterName = "ApplicationBasic";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "vendor-name", Attributes::VendorName::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "vendor-id", Attributes::VendorID::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "application-name", Attributes::ApplicationName::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "product-id", Attributes::ProductID::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "application", Attributes::Application::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "status", Attributes::Status::Id, credsIssuerConfig),                               //
        make_unique<ReadAttribute>(Id, "application-version", Attributes::ApplicationVersion::Id, credsIssuerConfig),      //
        make_unique<ReadAttribute>(Id, "allowed-vendor-list", Attributes::AllowedVendorList::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "vendor-name", Attributes::VendorName::Id, WriteCommandType::kForceWrite,
                                                    credsIssuerConfig), //
        make_unique<WriteAttribute<chip::VendorId>>(Id, "vendor-id", 0, UINT16_MAX, Attributes::VendorID::Id,
                                                    WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "application-name", Attributes::ApplicationName::Id,
                                                    WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "product-id", 0, UINT16_MAX, Attributes::ProductID::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::Clusters::ApplicationBasic::Structs::ApplicationStruct::Type>>(
            Id, "application", Attributes::Application::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::ApplicationBasic::ApplicationStatusEnum>>(
            Id, "status", 0, UINT8_MAX, Attributes::Status::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "application-version", Attributes::ApplicationVersion::Id,
                                                    WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::VendorId>>>(
            Id, "allowed-vendor-list", Attributes::AllowedVendorList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "vendor-name", Attributes::VendorName::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "vendor-id", Attributes::VendorID::Id, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, "application-name", Attributes::ApplicationName::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "product-id", Attributes::ProductID::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "application", Attributes::Application::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "status", Attributes::Status::Id, credsIssuerConfig),                               //
        make_unique<SubscribeAttribute>(Id, "application-version", Attributes::ApplicationVersion::Id, credsIssuerConfig),      //
        make_unique<SubscribeAttribute>(Id, "allowed-vendor-list", Attributes::AllowedVendorList::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterAccountLogin(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::AccountLogin;

    const char * clusterName = "AccountLogin";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),      //
        make_unique<AccountLoginGetSetupPIN>(credsIssuerConfig), //
        make_unique<AccountLoginLogin>(credsIssuerConfig),       //
        make_unique<AccountLoginLogout>(credsIssuerConfig),      //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                           //
        make_unique<ReadEvent>(Id, "logged-out", Events::LoggedOut::Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                      //
        make_unique<SubscribeEvent>(Id, "logged-out", Events::LoggedOut::Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterContentControl(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::ContentControl;

    const char * clusterName = "ContentControl";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                               //
        make_unique<ContentControlUpdatePIN>(credsIssuerConfig),                          //
        make_unique<ContentControlResetPIN>(credsIssuerConfig),                           //
        make_unique<ContentControlEnable>(credsIssuerConfig),                             //
        make_unique<ContentControlDisable>(credsIssuerConfig),                            //
        make_unique<ContentControlAddBonusTime>(credsIssuerConfig),                       //
        make_unique<ContentControlSetScreenDailyTime>(credsIssuerConfig),                 //
        make_unique<ContentControlBlockUnratedContent>(credsIssuerConfig),                //
        make_unique<ContentControlUnblockUnratedContent>(credsIssuerConfig),              //
        make_unique<ContentControlSetOnDemandRatingThreshold>(credsIssuerConfig),         //
        make_unique<ContentControlSetScheduledContentRatingThreshold>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                        //
        make_unique<ReadAttribute>(Id, "enabled", Attributes::Enabled::Id, credsIssuerConfig),                                    //
        make_unique<ReadAttribute>(Id, "on-demand-ratings", Attributes::OnDemandRatings::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "on-demand-rating-threshold", Attributes::OnDemandRatingThreshold::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "scheduled-content-ratings", Attributes::ScheduledContentRatings::Id, credsIssuerConfig),  //
        make_unique<ReadAttribute>(Id, "scheduled-content-rating-threshold", Attributes::ScheduledContentRatingThreshold::Id,
                                   credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "screen-daily-time", Attributes::ScreenDailyTime::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "remaining-screen-time", Attributes::RemainingScreenTime::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "block-unrated", Attributes::BlockUnrated::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<bool>>(Id, "enabled", 0, 1, Attributes::Enabled::Id, WriteCommandType::kForceWrite,
                                          credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::ContentControl::Structs::RatingNameStruct::Type>>>(
            Id, "on-demand-ratings", Attributes::OnDemandRatings::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "on-demand-rating-threshold", Attributes::OnDemandRatingThreshold::Id,
                                                    WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::ContentControl::Structs::RatingNameStruct::Type>>>(
            Id, "scheduled-content-ratings", Attributes::ScheduledContentRatings::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "scheduled-content-rating-threshold",
                                                    Attributes::ScheduledContentRatingThreshold::Id, WriteCommandType::kForceWrite,
                                                    credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "screen-daily-time", 0, UINT32_MAX, Attributes::ScreenDailyTime::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "remaining-screen-time", 0, UINT32_MAX, Attributes::RemainingScreenTime::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<bool>>(Id, "block-unrated", 0, 1, Attributes::BlockUnrated::Id, WriteCommandType::kForceWrite,
                                          credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                       //
        make_unique<SubscribeAttribute>(Id, "enabled", Attributes::Enabled::Id, credsIssuerConfig),                   //
        make_unique<SubscribeAttribute>(Id, "on-demand-ratings", Attributes::OnDemandRatings::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "on-demand-rating-threshold", Attributes::OnDemandRatingThreshold::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "scheduled-content-ratings", Attributes::ScheduledContentRatings::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "scheduled-content-rating-threshold", Attributes::ScheduledContentRatingThreshold::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "screen-daily-time", Attributes::ScreenDailyTime::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "remaining-screen-time", Attributes::RemainingScreenTime::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "block-unrated", Attributes::BlockUnrated::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                                          //
        make_unique<ReadEvent>(Id, "remaining-screen-time-expired", Events::RemainingScreenTimeExpired::Id, credsIssuerConfig), //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                                     //
        make_unique<SubscribeEvent>(Id, "remaining-screen-time-expired", Events::RemainingScreenTimeExpired::Id,
                                    credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterContentAppObserver(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::ContentAppObserver;

    const char * clusterName = "ContentAppObserver";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                  //
        make_unique<ContentAppObserverContentAppMessage>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterElectricalMeasurement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::ElectricalMeasurement;

    const char * clusterName = "ElectricalMeasurement";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                                //
        make_unique<ElectricalMeasurementGetProfileInfoCommand>(credsIssuerConfig),        //
        make_unique<ElectricalMeasurementGetMeasurementProfileCommand>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                               //
        make_unique<ReadAttribute>(Id, "measurement-type", Attributes::MeasurementType::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "dc-voltage", Attributes::DcVoltage::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "dc-voltage-min", Attributes::DcVoltageMin::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "dc-voltage-max", Attributes::DcVoltageMax::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "dc-current", Attributes::DcCurrent::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "dc-current-min", Attributes::DcCurrentMin::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "dc-current-max", Attributes::DcCurrentMax::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "dc-power", Attributes::DcPower::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "dc-power-min", Attributes::DcPowerMin::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "dc-power-max", Attributes::DcPowerMax::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "dc-voltage-multiplier", Attributes::DcVoltageMultiplier::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "dc-voltage-divisor", Attributes::DcVoltageDivisor::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "dc-current-multiplier", Attributes::DcCurrentMultiplier::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "dc-current-divisor", Attributes::DcCurrentDivisor::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "dc-power-multiplier", Attributes::DcPowerMultiplier::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "dc-power-divisor", Attributes::DcPowerDivisor::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "ac-frequency", Attributes::AcFrequency::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "ac-frequency-min", Attributes::AcFrequencyMin::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "ac-frequency-max", Attributes::AcFrequencyMax::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "neutral-current", Attributes::NeutralCurrent::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "total-active-power", Attributes::TotalActivePower::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "total-reactive-power", Attributes::TotalReactivePower::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "total-apparent-power", Attributes::TotalApparentPower::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "measured1st-harmonic-current", Attributes::Measured1stHarmonicCurrent::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "measured3rd-harmonic-current", Attributes::Measured3rdHarmonicCurrent::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "measured5th-harmonic-current", Attributes::Measured5thHarmonicCurrent::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "measured7th-harmonic-current", Attributes::Measured7thHarmonicCurrent::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "measured9th-harmonic-current", Attributes::Measured9thHarmonicCurrent::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "measured11th-harmonic-current", Attributes::Measured11thHarmonicCurrent::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "measured-phase1st-harmonic-current", Attributes::MeasuredPhase1stHarmonicCurrent::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "measured-phase3rd-harmonic-current", Attributes::MeasuredPhase3rdHarmonicCurrent::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "measured-phase5th-harmonic-current", Attributes::MeasuredPhase5thHarmonicCurrent::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "measured-phase7th-harmonic-current", Attributes::MeasuredPhase7thHarmonicCurrent::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "measured-phase9th-harmonic-current", Attributes::MeasuredPhase9thHarmonicCurrent::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "measured-phase11th-harmonic-current", Attributes::MeasuredPhase11thHarmonicCurrent::Id,
                                   credsIssuerConfig),                                                                       //
        make_unique<ReadAttribute>(Id, "ac-frequency-multiplier", Attributes::AcFrequencyMultiplier::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "ac-frequency-divisor", Attributes::AcFrequencyDivisor::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "power-multiplier", Attributes::PowerMultiplier::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "power-divisor", Attributes::PowerDivisor::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "harmonic-current-multiplier", Attributes::HarmonicCurrentMultiplier::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "phase-harmonic-current-multiplier", Attributes::PhaseHarmonicCurrentMultiplier::Id,
                                   credsIssuerConfig),                                                                    //
        make_unique<ReadAttribute>(Id, "instantaneous-voltage", Attributes::InstantaneousVoltage::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "instantaneous-line-current", Attributes::InstantaneousLineCurrent::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "instantaneous-active-current", Attributes::InstantaneousActiveCurrent::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "instantaneous-reactive-current", Attributes::InstantaneousReactiveCurrent::Id,
                                   credsIssuerConfig),                                                                //
        make_unique<ReadAttribute>(Id, "instantaneous-power", Attributes::InstantaneousPower::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "rms-voltage", Attributes::RmsVoltage::Id, credsIssuerConfig),                 //
        make_unique<ReadAttribute>(Id, "rms-voltage-min", Attributes::RmsVoltageMin::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "rms-voltage-max", Attributes::RmsVoltageMax::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "rms-current", Attributes::RmsCurrent::Id, credsIssuerConfig),                 //
        make_unique<ReadAttribute>(Id, "rms-current-min", Attributes::RmsCurrentMin::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "rms-current-max", Attributes::RmsCurrentMax::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "active-power", Attributes::ActivePower::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "active-power-min", Attributes::ActivePowerMin::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "active-power-max", Attributes::ActivePowerMax::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "reactive-power", Attributes::ReactivePower::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "apparent-power", Attributes::ApparentPower::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "power-factor", Attributes::PowerFactor::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "average-rms-voltage-measurement-period", Attributes::AverageRmsVoltageMeasurementPeriod::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "average-rms-under-voltage-counter", Attributes::AverageRmsUnderVoltageCounter::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "rms-extreme-over-voltage-period", Attributes::RmsExtremeOverVoltagePeriod::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "rms-extreme-under-voltage-period", Attributes::RmsExtremeUnderVoltagePeriod::Id,
                                   credsIssuerConfig),                                                                            //
        make_unique<ReadAttribute>(Id, "rms-voltage-sag-period", Attributes::RmsVoltageSagPeriod::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "rms-voltage-swell-period", Attributes::RmsVoltageSwellPeriod::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "ac-voltage-multiplier", Attributes::AcVoltageMultiplier::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "ac-voltage-divisor", Attributes::AcVoltageDivisor::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "ac-current-multiplier", Attributes::AcCurrentMultiplier::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "ac-current-divisor", Attributes::AcCurrentDivisor::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "ac-power-multiplier", Attributes::AcPowerMultiplier::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "ac-power-divisor", Attributes::AcPowerDivisor::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "overload-alarms-mask", Attributes::OverloadAlarmsMask::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "voltage-overload", Attributes::VoltageOverload::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "current-overload", Attributes::CurrentOverload::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "ac-overload-alarms-mask", Attributes::AcOverloadAlarmsMask::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "ac-voltage-overload", Attributes::AcVoltageOverload::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "ac-current-overload", Attributes::AcCurrentOverload::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "ac-active-power-overload", Attributes::AcActivePowerOverload::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "ac-reactive-power-overload", Attributes::AcReactivePowerOverload::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "average-rms-over-voltage", Attributes::AverageRmsOverVoltage::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "average-rms-under-voltage", Attributes::AverageRmsUnderVoltage::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "rms-extreme-over-voltage", Attributes::RmsExtremeOverVoltage::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "rms-extreme-under-voltage", Attributes::RmsExtremeUnderVoltage::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "rms-voltage-sag", Attributes::RmsVoltageSag::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "rms-voltage-swell", Attributes::RmsVoltageSwell::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "line-current-phase-b", Attributes::LineCurrentPhaseB::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "active-current-phase-b", Attributes::ActiveCurrentPhaseB::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "reactive-current-phase-b", Attributes::ReactiveCurrentPhaseB::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "rms-voltage-phase-b", Attributes::RmsVoltagePhaseB::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "rms-voltage-min-phase-b", Attributes::RmsVoltageMinPhaseB::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "rms-voltage-max-phase-b", Attributes::RmsVoltageMaxPhaseB::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "rms-current-phase-b", Attributes::RmsCurrentPhaseB::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "rms-current-min-phase-b", Attributes::RmsCurrentMinPhaseB::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "rms-current-max-phase-b", Attributes::RmsCurrentMaxPhaseB::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "active-power-phase-b", Attributes::ActivePowerPhaseB::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "active-power-min-phase-b", Attributes::ActivePowerMinPhaseB::Id, credsIssuerConfig),      //
        make_unique<ReadAttribute>(Id, "active-power-max-phase-b", Attributes::ActivePowerMaxPhaseB::Id, credsIssuerConfig),      //
        make_unique<ReadAttribute>(Id, "reactive-power-phase-b", Attributes::ReactivePowerPhaseB::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "apparent-power-phase-b", Attributes::ApparentPowerPhaseB::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "power-factor-phase-b", Attributes::PowerFactorPhaseB::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "average-rms-voltage-measurement-period-phase-b",
                                   Attributes::AverageRmsVoltageMeasurementPeriodPhaseB::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "average-rms-over-voltage-counter-phase-b",
                                   Attributes::AverageRmsOverVoltageCounterPhaseB::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "average-rms-under-voltage-counter-phase-b",
                                   Attributes::AverageRmsUnderVoltageCounterPhaseB::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "rms-extreme-over-voltage-period-phase-b", Attributes::RmsExtremeOverVoltagePeriodPhaseB::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "rms-extreme-under-voltage-period-phase-b",
                                   Attributes::RmsExtremeUnderVoltagePeriodPhaseB::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "rms-voltage-sag-period-phase-b", Attributes::RmsVoltageSagPeriodPhaseB::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "rms-voltage-swell-period-phase-b", Attributes::RmsVoltageSwellPeriodPhaseB::Id,
                                   credsIssuerConfig),                                                                        //
        make_unique<ReadAttribute>(Id, "line-current-phase-c", Attributes::LineCurrentPhaseC::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "active-current-phase-c", Attributes::ActiveCurrentPhaseC::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "reactive-current-phase-c", Attributes::ReactiveCurrentPhaseC::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "rms-voltage-phase-c", Attributes::RmsVoltagePhaseC::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "rms-voltage-min-phase-c", Attributes::RmsVoltageMinPhaseC::Id, credsIssuerConfig),    //
        make_unique<ReadAttribute>(Id, "rms-voltage-max-phase-c", Attributes::RmsVoltageMaxPhaseC::Id, credsIssuerConfig),    //
        make_unique<ReadAttribute>(Id, "rms-current-phase-c", Attributes::RmsCurrentPhaseC::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "rms-current-min-phase-c", Attributes::RmsCurrentMinPhaseC::Id, credsIssuerConfig),    //
        make_unique<ReadAttribute>(Id, "rms-current-max-phase-c", Attributes::RmsCurrentMaxPhaseC::Id, credsIssuerConfig),    //
        make_unique<ReadAttribute>(Id, "active-power-phase-c", Attributes::ActivePowerPhaseC::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "active-power-min-phase-c", Attributes::ActivePowerMinPhaseC::Id, credsIssuerConfig),  //
        make_unique<ReadAttribute>(Id, "active-power-max-phase-c", Attributes::ActivePowerMaxPhaseC::Id, credsIssuerConfig),  //
        make_unique<ReadAttribute>(Id, "reactive-power-phase-c", Attributes::ReactivePowerPhaseC::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "apparent-power-phase-c", Attributes::ApparentPowerPhaseC::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "power-factor-phase-c", Attributes::PowerFactorPhaseC::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "average-rms-voltage-measurement-period-phase-c",
                                   Attributes::AverageRmsVoltageMeasurementPeriodPhaseC::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "average-rms-over-voltage-counter-phase-c",
                                   Attributes::AverageRmsOverVoltageCounterPhaseC::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "average-rms-under-voltage-counter-phase-c",
                                   Attributes::AverageRmsUnderVoltageCounterPhaseC::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "rms-extreme-over-voltage-period-phase-c", Attributes::RmsExtremeOverVoltagePeriodPhaseC::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "rms-extreme-under-voltage-period-phase-c",
                                   Attributes::RmsExtremeUnderVoltagePeriodPhaseC::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "rms-voltage-sag-period-phase-c", Attributes::RmsVoltageSagPeriodPhaseC::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "rms-voltage-swell-period-phase-c", Attributes::RmsVoltageSwellPeriodPhaseC::Id,
                                   credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<uint32_t>>(Id, "measurement-type", 0, UINT32_MAX, Attributes::MeasurementType::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "dc-voltage", INT16_MIN, INT16_MAX, Attributes::DcVoltage::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "dc-voltage-min", INT16_MIN, INT16_MAX, Attributes::DcVoltageMin::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "dc-voltage-max", INT16_MIN, INT16_MAX, Attributes::DcVoltageMax::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "dc-current", INT16_MIN, INT16_MAX, Attributes::DcCurrent::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "dc-current-min", INT16_MIN, INT16_MAX, Attributes::DcCurrentMin::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "dc-current-max", INT16_MIN, INT16_MAX, Attributes::DcCurrentMax::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "dc-power", INT16_MIN, INT16_MAX, Attributes::DcPower::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "dc-power-min", INT16_MIN, INT16_MAX, Attributes::DcPowerMin::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "dc-power-max", INT16_MIN, INT16_MAX, Attributes::DcPowerMax::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "dc-voltage-multiplier", 0, UINT16_MAX, Attributes::DcVoltageMultiplier::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "dc-voltage-divisor", 0, UINT16_MAX, Attributes::DcVoltageDivisor::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "dc-current-multiplier", 0, UINT16_MAX, Attributes::DcCurrentMultiplier::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "dc-current-divisor", 0, UINT16_MAX, Attributes::DcCurrentDivisor::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "dc-power-multiplier", 0, UINT16_MAX, Attributes::DcPowerMultiplier::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "dc-power-divisor", 0, UINT16_MAX, Attributes::DcPowerDivisor::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "ac-frequency", 0, UINT16_MAX, Attributes::AcFrequency::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "ac-frequency-min", 0, UINT16_MAX, Attributes::AcFrequencyMin::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "ac-frequency-max", 0, UINT16_MAX, Attributes::AcFrequencyMax::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "neutral-current", 0, UINT16_MAX, Attributes::NeutralCurrent::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int32_t>>(Id, "total-active-power", INT32_MIN, INT32_MAX, Attributes::TotalActivePower::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int32_t>>(Id, "total-reactive-power", INT32_MIN, INT32_MAX, Attributes::TotalReactivePower::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "total-apparent-power", 0, UINT32_MAX, Attributes::TotalApparentPower::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "measured1st-harmonic-current", INT16_MIN, INT16_MAX,
                                             Attributes::Measured1stHarmonicCurrent::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "measured3rd-harmonic-current", INT16_MIN, INT16_MAX,
                                             Attributes::Measured3rdHarmonicCurrent::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "measured5th-harmonic-current", INT16_MIN, INT16_MAX,
                                             Attributes::Measured5thHarmonicCurrent::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "measured7th-harmonic-current", INT16_MIN, INT16_MAX,
                                             Attributes::Measured7thHarmonicCurrent::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "measured9th-harmonic-current", INT16_MIN, INT16_MAX,
                                             Attributes::Measured9thHarmonicCurrent::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "measured11th-harmonic-current", INT16_MIN, INT16_MAX,
                                             Attributes::Measured11thHarmonicCurrent::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "measured-phase1st-harmonic-current", INT16_MIN, INT16_MAX,
                                             Attributes::MeasuredPhase1stHarmonicCurrent::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "measured-phase3rd-harmonic-current", INT16_MIN, INT16_MAX,
                                             Attributes::MeasuredPhase3rdHarmonicCurrent::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "measured-phase5th-harmonic-current", INT16_MIN, INT16_MAX,
                                             Attributes::MeasuredPhase5thHarmonicCurrent::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "measured-phase7th-harmonic-current", INT16_MIN, INT16_MAX,
                                             Attributes::MeasuredPhase7thHarmonicCurrent::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "measured-phase9th-harmonic-current", INT16_MIN, INT16_MAX,
                                             Attributes::MeasuredPhase9thHarmonicCurrent::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "measured-phase11th-harmonic-current", INT16_MIN, INT16_MAX,
                                             Attributes::MeasuredPhase11thHarmonicCurrent::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "ac-frequency-multiplier", 0, UINT16_MAX, Attributes::AcFrequencyMultiplier::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "ac-frequency-divisor", 0, UINT16_MAX, Attributes::AcFrequencyDivisor::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "power-multiplier", 0, UINT32_MAX, Attributes::PowerMultiplier::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "power-divisor", 0, UINT32_MAX, Attributes::PowerDivisor::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int8_t>>(Id, "harmonic-current-multiplier", INT8_MIN, INT8_MAX,
                                            Attributes::HarmonicCurrentMultiplier::Id, WriteCommandType::kForceWrite,
                                            credsIssuerConfig), //
        make_unique<WriteAttribute<int8_t>>(Id, "phase-harmonic-current-multiplier", INT8_MIN, INT8_MAX,
                                            Attributes::PhaseHarmonicCurrentMultiplier::Id, WriteCommandType::kForceWrite,
                                            credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "instantaneous-voltage", INT16_MIN, INT16_MAX,
                                             Attributes::InstantaneousVoltage::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "instantaneous-line-current", 0, UINT16_MAX,
                                              Attributes::InstantaneousLineCurrent::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "instantaneous-active-current", INT16_MIN, INT16_MAX,
                                             Attributes::InstantaneousActiveCurrent::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "instantaneous-reactive-current", INT16_MIN, INT16_MAX,
                                             Attributes::InstantaneousReactiveCurrent::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "instantaneous-power", INT16_MIN, INT16_MAX, Attributes::InstantaneousPower::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "rms-voltage", 0, UINT16_MAX, Attributes::RmsVoltage::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "rms-voltage-min", 0, UINT16_MAX, Attributes::RmsVoltageMin::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "rms-voltage-max", 0, UINT16_MAX, Attributes::RmsVoltageMax::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "rms-current", 0, UINT16_MAX, Attributes::RmsCurrent::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "rms-current-min", 0, UINT16_MAX, Attributes::RmsCurrentMin::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "rms-current-max", 0, UINT16_MAX, Attributes::RmsCurrentMax::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "active-power", INT16_MIN, INT16_MAX, Attributes::ActivePower::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "active-power-min", INT16_MIN, INT16_MAX, Attributes::ActivePowerMin::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "active-power-max", INT16_MIN, INT16_MAX, Attributes::ActivePowerMax::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "reactive-power", INT16_MIN, INT16_MAX, Attributes::ReactivePower::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "apparent-power", 0, UINT16_MAX, Attributes::ApparentPower::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int8_t>>(Id, "power-factor", INT8_MIN, INT8_MAX, Attributes::PowerFactor::Id,
                                            WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "average-rms-voltage-measurement-period", 0, UINT16_MAX,
                                              Attributes::AverageRmsVoltageMeasurementPeriod::Id, WriteCommandType::kWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "average-rms-under-voltage-counter", 0, UINT16_MAX,
                                              Attributes::AverageRmsUnderVoltageCounter::Id, WriteCommandType::kWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "rms-extreme-over-voltage-period", 0, UINT16_MAX,
                                              Attributes::RmsExtremeOverVoltagePeriod::Id, WriteCommandType::kWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "rms-extreme-under-voltage-period", 0, UINT16_MAX,
                                              Attributes::RmsExtremeUnderVoltagePeriod::Id, WriteCommandType::kWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "rms-voltage-sag-period", 0, UINT16_MAX, Attributes::RmsVoltageSagPeriod::Id,
                                              WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "rms-voltage-swell-period", 0, UINT16_MAX, Attributes::RmsVoltageSwellPeriod::Id,
                                              WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "ac-voltage-multiplier", 0, UINT16_MAX, Attributes::AcVoltageMultiplier::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "ac-voltage-divisor", 0, UINT16_MAX, Attributes::AcVoltageDivisor::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "ac-current-multiplier", 0, UINT16_MAX, Attributes::AcCurrentMultiplier::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "ac-current-divisor", 0, UINT16_MAX, Attributes::AcCurrentDivisor::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "ac-power-multiplier", 0, UINT16_MAX, Attributes::AcPowerMultiplier::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "ac-power-divisor", 0, UINT16_MAX, Attributes::AcPowerDivisor::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "overload-alarms-mask", 0, UINT8_MAX, Attributes::OverloadAlarmsMask::Id,
                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "voltage-overload", INT16_MIN, INT16_MAX, Attributes::VoltageOverload::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "current-overload", INT16_MIN, INT16_MAX, Attributes::CurrentOverload::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "ac-overload-alarms-mask", 0, UINT16_MAX, Attributes::AcOverloadAlarmsMask::Id,
                                              WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "ac-voltage-overload", INT16_MIN, INT16_MAX, Attributes::AcVoltageOverload::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "ac-current-overload", INT16_MIN, INT16_MAX, Attributes::AcCurrentOverload::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "ac-active-power-overload", INT16_MIN, INT16_MAX,
                                             Attributes::AcActivePowerOverload::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "ac-reactive-power-overload", INT16_MIN, INT16_MAX,
                                             Attributes::AcReactivePowerOverload::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "average-rms-over-voltage", INT16_MIN, INT16_MAX,
                                             Attributes::AverageRmsOverVoltage::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "average-rms-under-voltage", INT16_MIN, INT16_MAX,
                                             Attributes::AverageRmsUnderVoltage::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "rms-extreme-over-voltage", INT16_MIN, INT16_MAX,
                                             Attributes::RmsExtremeOverVoltage::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "rms-extreme-under-voltage", INT16_MIN, INT16_MAX,
                                             Attributes::RmsExtremeUnderVoltage::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "rms-voltage-sag", INT16_MIN, INT16_MAX, Attributes::RmsVoltageSag::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "rms-voltage-swell", INT16_MIN, INT16_MAX, Attributes::RmsVoltageSwell::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "line-current-phase-b", 0, UINT16_MAX, Attributes::LineCurrentPhaseB::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "active-current-phase-b", INT16_MIN, INT16_MAX,
                                             Attributes::ActiveCurrentPhaseB::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "reactive-current-phase-b", INT16_MIN, INT16_MAX,
                                             Attributes::ReactiveCurrentPhaseB::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "rms-voltage-phase-b", 0, UINT16_MAX, Attributes::RmsVoltagePhaseB::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "rms-voltage-min-phase-b", 0, UINT16_MAX, Attributes::RmsVoltageMinPhaseB::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "rms-voltage-max-phase-b", 0, UINT16_MAX, Attributes::RmsVoltageMaxPhaseB::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "rms-current-phase-b", 0, UINT16_MAX, Attributes::RmsCurrentPhaseB::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "rms-current-min-phase-b", 0, UINT16_MAX, Attributes::RmsCurrentMinPhaseB::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "rms-current-max-phase-b", 0, UINT16_MAX, Attributes::RmsCurrentMaxPhaseB::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "active-power-phase-b", INT16_MIN, INT16_MAX, Attributes::ActivePowerPhaseB::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "active-power-min-phase-b", INT16_MIN, INT16_MAX,
                                             Attributes::ActivePowerMinPhaseB::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "active-power-max-phase-b", INT16_MIN, INT16_MAX,
                                             Attributes::ActivePowerMaxPhaseB::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "reactive-power-phase-b", INT16_MIN, INT16_MAX,
                                             Attributes::ReactivePowerPhaseB::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "apparent-power-phase-b", 0, UINT16_MAX, Attributes::ApparentPowerPhaseB::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int8_t>>(Id, "power-factor-phase-b", INT8_MIN, INT8_MAX, Attributes::PowerFactorPhaseB::Id,
                                            WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "average-rms-voltage-measurement-period-phase-b", 0, UINT16_MAX,
                                              Attributes::AverageRmsVoltageMeasurementPeriodPhaseB::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "average-rms-over-voltage-counter-phase-b", 0, UINT16_MAX,
                                              Attributes::AverageRmsOverVoltageCounterPhaseB::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "average-rms-under-voltage-counter-phase-b", 0, UINT16_MAX,
                                              Attributes::AverageRmsUnderVoltageCounterPhaseB::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "rms-extreme-over-voltage-period-phase-b", 0, UINT16_MAX,
                                              Attributes::RmsExtremeOverVoltagePeriodPhaseB::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "rms-extreme-under-voltage-period-phase-b", 0, UINT16_MAX,
                                              Attributes::RmsExtremeUnderVoltagePeriodPhaseB::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "rms-voltage-sag-period-phase-b", 0, UINT16_MAX,
                                              Attributes::RmsVoltageSagPeriodPhaseB::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "rms-voltage-swell-period-phase-b", 0, UINT16_MAX,
                                              Attributes::RmsVoltageSwellPeriodPhaseB::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "line-current-phase-c", 0, UINT16_MAX, Attributes::LineCurrentPhaseC::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "active-current-phase-c", INT16_MIN, INT16_MAX,
                                             Attributes::ActiveCurrentPhaseC::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "reactive-current-phase-c", INT16_MIN, INT16_MAX,
                                             Attributes::ReactiveCurrentPhaseC::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "rms-voltage-phase-c", 0, UINT16_MAX, Attributes::RmsVoltagePhaseC::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "rms-voltage-min-phase-c", 0, UINT16_MAX, Attributes::RmsVoltageMinPhaseC::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "rms-voltage-max-phase-c", 0, UINT16_MAX, Attributes::RmsVoltageMaxPhaseC::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "rms-current-phase-c", 0, UINT16_MAX, Attributes::RmsCurrentPhaseC::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "rms-current-min-phase-c", 0, UINT16_MAX, Attributes::RmsCurrentMinPhaseC::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "rms-current-max-phase-c", 0, UINT16_MAX, Attributes::RmsCurrentMaxPhaseC::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "active-power-phase-c", INT16_MIN, INT16_MAX, Attributes::ActivePowerPhaseC::Id,
                                             WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "active-power-min-phase-c", INT16_MIN, INT16_MAX,
                                             Attributes::ActivePowerMinPhaseC::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "active-power-max-phase-c", INT16_MIN, INT16_MAX,
                                             Attributes::ActivePowerMaxPhaseC::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "reactive-power-phase-c", INT16_MIN, INT16_MAX,
                                             Attributes::ReactivePowerPhaseC::Id, WriteCommandType::kForceWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "apparent-power-phase-c", 0, UINT16_MAX, Attributes::ApparentPowerPhaseC::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int8_t>>(Id, "power-factor-phase-c", INT8_MIN, INT8_MAX, Attributes::PowerFactorPhaseC::Id,
                                            WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "average-rms-voltage-measurement-period-phase-c", 0, UINT16_MAX,
                                              Attributes::AverageRmsVoltageMeasurementPeriodPhaseC::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "average-rms-over-voltage-counter-phase-c", 0, UINT16_MAX,
                                              Attributes::AverageRmsOverVoltageCounterPhaseC::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "average-rms-under-voltage-counter-phase-c", 0, UINT16_MAX,
                                              Attributes::AverageRmsUnderVoltageCounterPhaseC::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "rms-extreme-over-voltage-period-phase-c", 0, UINT16_MAX,
                                              Attributes::RmsExtremeOverVoltagePeriodPhaseC::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "rms-extreme-under-voltage-period-phase-c", 0, UINT16_MAX,
                                              Attributes::RmsExtremeUnderVoltagePeriodPhaseC::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "rms-voltage-sag-period-phase-c", 0, UINT16_MAX,
                                              Attributes::RmsVoltageSagPeriodPhaseC::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "rms-voltage-swell-period-phase-c", 0, UINT16_MAX,
                                              Attributes::RmsVoltageSwellPeriodPhaseC::Id, WriteCommandType::kForceWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                              //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                               //
        make_unique<SubscribeAttribute>(Id, "measurement-type", Attributes::MeasurementType::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "dc-voltage", Attributes::DcVoltage::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "dc-voltage-min", Attributes::DcVoltageMin::Id, credsIssuerConfig),               //
        make_unique<SubscribeAttribute>(Id, "dc-voltage-max", Attributes::DcVoltageMax::Id, credsIssuerConfig),               //
        make_unique<SubscribeAttribute>(Id, "dc-current", Attributes::DcCurrent::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "dc-current-min", Attributes::DcCurrentMin::Id, credsIssuerConfig),               //
        make_unique<SubscribeAttribute>(Id, "dc-current-max", Attributes::DcCurrentMax::Id, credsIssuerConfig),               //
        make_unique<SubscribeAttribute>(Id, "dc-power", Attributes::DcPower::Id, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, "dc-power-min", Attributes::DcPowerMin::Id, credsIssuerConfig),                   //
        make_unique<SubscribeAttribute>(Id, "dc-power-max", Attributes::DcPowerMax::Id, credsIssuerConfig),                   //
        make_unique<SubscribeAttribute>(Id, "dc-voltage-multiplier", Attributes::DcVoltageMultiplier::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "dc-voltage-divisor", Attributes::DcVoltageDivisor::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "dc-current-multiplier", Attributes::DcCurrentMultiplier::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "dc-current-divisor", Attributes::DcCurrentDivisor::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "dc-power-multiplier", Attributes::DcPowerMultiplier::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "dc-power-divisor", Attributes::DcPowerDivisor::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "ac-frequency", Attributes::AcFrequency::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "ac-frequency-min", Attributes::AcFrequencyMin::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "ac-frequency-max", Attributes::AcFrequencyMax::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "neutral-current", Attributes::NeutralCurrent::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "total-active-power", Attributes::TotalActivePower::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "total-reactive-power", Attributes::TotalReactivePower::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "total-apparent-power", Attributes::TotalApparentPower::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "measured1st-harmonic-current", Attributes::Measured1stHarmonicCurrent::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "measured3rd-harmonic-current", Attributes::Measured3rdHarmonicCurrent::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "measured5th-harmonic-current", Attributes::Measured5thHarmonicCurrent::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "measured7th-harmonic-current", Attributes::Measured7thHarmonicCurrent::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "measured9th-harmonic-current", Attributes::Measured9thHarmonicCurrent::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "measured11th-harmonic-current", Attributes::Measured11thHarmonicCurrent::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "measured-phase1st-harmonic-current", Attributes::MeasuredPhase1stHarmonicCurrent::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "measured-phase3rd-harmonic-current", Attributes::MeasuredPhase3rdHarmonicCurrent::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "measured-phase5th-harmonic-current", Attributes::MeasuredPhase5thHarmonicCurrent::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "measured-phase7th-harmonic-current", Attributes::MeasuredPhase7thHarmonicCurrent::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "measured-phase9th-harmonic-current", Attributes::MeasuredPhase9thHarmonicCurrent::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "measured-phase11th-harmonic-current", Attributes::MeasuredPhase11thHarmonicCurrent::Id,
                                        credsIssuerConfig),                                                                       //
        make_unique<SubscribeAttribute>(Id, "ac-frequency-multiplier", Attributes::AcFrequencyMultiplier::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "ac-frequency-divisor", Attributes::AcFrequencyDivisor::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "power-multiplier", Attributes::PowerMultiplier::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "power-divisor", Attributes::PowerDivisor::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "harmonic-current-multiplier", Attributes::HarmonicCurrentMultiplier::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "phase-harmonic-current-multiplier", Attributes::PhaseHarmonicCurrentMultiplier::Id,
                                        credsIssuerConfig),                                                                    //
        make_unique<SubscribeAttribute>(Id, "instantaneous-voltage", Attributes::InstantaneousVoltage::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "instantaneous-line-current", Attributes::InstantaneousLineCurrent::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "instantaneous-active-current", Attributes::InstantaneousActiveCurrent::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "instantaneous-reactive-current", Attributes::InstantaneousReactiveCurrent::Id,
                                        credsIssuerConfig),                                                                //
        make_unique<SubscribeAttribute>(Id, "instantaneous-power", Attributes::InstantaneousPower::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "rms-voltage", Attributes::RmsVoltage::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "rms-voltage-min", Attributes::RmsVoltageMin::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "rms-voltage-max", Attributes::RmsVoltageMax::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "rms-current", Attributes::RmsCurrent::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "rms-current-min", Attributes::RmsCurrentMin::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "rms-current-max", Attributes::RmsCurrentMax::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "active-power", Attributes::ActivePower::Id, credsIssuerConfig),               //
        make_unique<SubscribeAttribute>(Id, "active-power-min", Attributes::ActivePowerMin::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "active-power-max", Attributes::ActivePowerMax::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "reactive-power", Attributes::ReactivePower::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "apparent-power", Attributes::ApparentPower::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "power-factor", Attributes::PowerFactor::Id, credsIssuerConfig),               //
        make_unique<SubscribeAttribute>(Id, "average-rms-voltage-measurement-period",
                                        Attributes::AverageRmsVoltageMeasurementPeriod::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "average-rms-under-voltage-counter", Attributes::AverageRmsUnderVoltageCounter::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "rms-extreme-over-voltage-period", Attributes::RmsExtremeOverVoltagePeriod::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "rms-extreme-under-voltage-period", Attributes::RmsExtremeUnderVoltagePeriod::Id,
                                        credsIssuerConfig),                                                                    //
        make_unique<SubscribeAttribute>(Id, "rms-voltage-sag-period", Attributes::RmsVoltageSagPeriod::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "rms-voltage-swell-period", Attributes::RmsVoltageSwellPeriod::Id,
                                        credsIssuerConfig),                                                                      //
        make_unique<SubscribeAttribute>(Id, "ac-voltage-multiplier", Attributes::AcVoltageMultiplier::Id, credsIssuerConfig),    //
        make_unique<SubscribeAttribute>(Id, "ac-voltage-divisor", Attributes::AcVoltageDivisor::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "ac-current-multiplier", Attributes::AcCurrentMultiplier::Id, credsIssuerConfig),    //
        make_unique<SubscribeAttribute>(Id, "ac-current-divisor", Attributes::AcCurrentDivisor::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "ac-power-multiplier", Attributes::AcPowerMultiplier::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "ac-power-divisor", Attributes::AcPowerDivisor::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "overload-alarms-mask", Attributes::OverloadAlarmsMask::Id, credsIssuerConfig),      //
        make_unique<SubscribeAttribute>(Id, "voltage-overload", Attributes::VoltageOverload::Id, credsIssuerConfig),             //
        make_unique<SubscribeAttribute>(Id, "current-overload", Attributes::CurrentOverload::Id, credsIssuerConfig),             //
        make_unique<SubscribeAttribute>(Id, "ac-overload-alarms-mask", Attributes::AcOverloadAlarmsMask::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "ac-voltage-overload", Attributes::AcVoltageOverload::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "ac-current-overload", Attributes::AcCurrentOverload::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "ac-active-power-overload", Attributes::AcActivePowerOverload::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "ac-reactive-power-overload", Attributes::AcReactivePowerOverload::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "average-rms-over-voltage", Attributes::AverageRmsOverVoltage::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "average-rms-under-voltage", Attributes::AverageRmsUnderVoltage::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "rms-extreme-over-voltage", Attributes::RmsExtremeOverVoltage::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "rms-extreme-under-voltage", Attributes::RmsExtremeUnderVoltage::Id,
                                        credsIssuerConfig),                                                                    //
        make_unique<SubscribeAttribute>(Id, "rms-voltage-sag", Attributes::RmsVoltageSag::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "rms-voltage-swell", Attributes::RmsVoltageSwell::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "line-current-phase-b", Attributes::LineCurrentPhaseB::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "active-current-phase-b", Attributes::ActiveCurrentPhaseB::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "reactive-current-phase-b", Attributes::ReactiveCurrentPhaseB::Id,
                                        credsIssuerConfig),                                                                       //
        make_unique<SubscribeAttribute>(Id, "rms-voltage-phase-b", Attributes::RmsVoltagePhaseB::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "rms-voltage-min-phase-b", Attributes::RmsVoltageMinPhaseB::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "rms-voltage-max-phase-b", Attributes::RmsVoltageMaxPhaseB::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "rms-current-phase-b", Attributes::RmsCurrentPhaseB::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "rms-current-min-phase-b", Attributes::RmsCurrentMinPhaseB::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "rms-current-max-phase-b", Attributes::RmsCurrentMaxPhaseB::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "active-power-phase-b", Attributes::ActivePowerPhaseB::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "active-power-min-phase-b", Attributes::ActivePowerMinPhaseB::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "active-power-max-phase-b", Attributes::ActivePowerMaxPhaseB::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "reactive-power-phase-b", Attributes::ReactivePowerPhaseB::Id, credsIssuerConfig),    //
        make_unique<SubscribeAttribute>(Id, "apparent-power-phase-b", Attributes::ApparentPowerPhaseB::Id, credsIssuerConfig),    //
        make_unique<SubscribeAttribute>(Id, "power-factor-phase-b", Attributes::PowerFactorPhaseB::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "average-rms-voltage-measurement-period-phase-b",
                                        Attributes::AverageRmsVoltageMeasurementPeriodPhaseB::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "average-rms-over-voltage-counter-phase-b",
                                        Attributes::AverageRmsOverVoltageCounterPhaseB::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "average-rms-under-voltage-counter-phase-b",
                                        Attributes::AverageRmsUnderVoltageCounterPhaseB::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "rms-extreme-over-voltage-period-phase-b",
                                        Attributes::RmsExtremeOverVoltagePeriodPhaseB::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "rms-extreme-under-voltage-period-phase-b",
                                        Attributes::RmsExtremeUnderVoltagePeriodPhaseB::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "rms-voltage-sag-period-phase-b", Attributes::RmsVoltageSagPeriodPhaseB::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "rms-voltage-swell-period-phase-b", Attributes::RmsVoltageSwellPeriodPhaseB::Id,
                                        credsIssuerConfig),                                                                    //
        make_unique<SubscribeAttribute>(Id, "line-current-phase-c", Attributes::LineCurrentPhaseC::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "active-current-phase-c", Attributes::ActiveCurrentPhaseC::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "reactive-current-phase-c", Attributes::ReactiveCurrentPhaseC::Id,
                                        credsIssuerConfig),                                                                       //
        make_unique<SubscribeAttribute>(Id, "rms-voltage-phase-c", Attributes::RmsVoltagePhaseC::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "rms-voltage-min-phase-c", Attributes::RmsVoltageMinPhaseC::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "rms-voltage-max-phase-c", Attributes::RmsVoltageMaxPhaseC::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "rms-current-phase-c", Attributes::RmsCurrentPhaseC::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "rms-current-min-phase-c", Attributes::RmsCurrentMinPhaseC::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "rms-current-max-phase-c", Attributes::RmsCurrentMaxPhaseC::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "active-power-phase-c", Attributes::ActivePowerPhaseC::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "active-power-min-phase-c", Attributes::ActivePowerMinPhaseC::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "active-power-max-phase-c", Attributes::ActivePowerMaxPhaseC::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "reactive-power-phase-c", Attributes::ReactivePowerPhaseC::Id, credsIssuerConfig),    //
        make_unique<SubscribeAttribute>(Id, "apparent-power-phase-c", Attributes::ApparentPowerPhaseC::Id, credsIssuerConfig),    //
        make_unique<SubscribeAttribute>(Id, "power-factor-phase-c", Attributes::PowerFactorPhaseC::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "average-rms-voltage-measurement-period-phase-c",
                                        Attributes::AverageRmsVoltageMeasurementPeriodPhaseC::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "average-rms-over-voltage-counter-phase-c",
                                        Attributes::AverageRmsOverVoltageCounterPhaseC::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "average-rms-under-voltage-counter-phase-c",
                                        Attributes::AverageRmsUnderVoltageCounterPhaseC::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "rms-extreme-over-voltage-period-phase-c",
                                        Attributes::RmsExtremeOverVoltagePeriodPhaseC::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "rms-extreme-under-voltage-period-phase-c",
                                        Attributes::RmsExtremeUnderVoltagePeriodPhaseC::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "rms-voltage-sag-period-phase-c", Attributes::RmsVoltageSagPeriodPhaseC::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "rms-voltage-swell-period-phase-c", Attributes::RmsVoltageSwellPeriodPhaseC::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterUnitTesting(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::UnitTesting;

    const char * clusterName = "UnitTesting";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                                 //
        make_unique<UnitTestingTest>(credsIssuerConfig),                                    //
        make_unique<UnitTestingTestNotHandled>(credsIssuerConfig),                          //
        make_unique<UnitTestingTestSpecific>(credsIssuerConfig),                            //
        make_unique<UnitTestingTestUnknownCommand>(credsIssuerConfig),                      //
        make_unique<UnitTestingTestAddArguments>(credsIssuerConfig),                        //
        make_unique<UnitTestingTestSimpleArgumentRequest>(credsIssuerConfig),               //
        make_unique<UnitTestingTestStructArrayArgumentRequest>(credsIssuerConfig),          //
        make_unique<UnitTestingTestStructArgumentRequest>(credsIssuerConfig),               //
        make_unique<UnitTestingTestNestedStructArgumentRequest>(credsIssuerConfig),         //
        make_unique<UnitTestingTestListStructArgumentRequest>(credsIssuerConfig),           //
        make_unique<UnitTestingTestListInt8UArgumentRequest>(credsIssuerConfig),            //
        make_unique<UnitTestingTestNestedStructListArgumentRequest>(credsIssuerConfig),     //
        make_unique<UnitTestingTestListNestedStructListArgumentRequest>(credsIssuerConfig), //
        make_unique<UnitTestingTestListInt8UReverseRequest>(credsIssuerConfig),             //
        make_unique<UnitTestingTestEnumsRequest>(credsIssuerConfig),                        //
        make_unique<UnitTestingTestNullableOptionalRequest>(credsIssuerConfig),             //
        make_unique<UnitTestingTestComplexNullableOptionalRequest>(credsIssuerConfig),      //
        make_unique<UnitTestingSimpleStructEchoRequest>(credsIssuerConfig),                 //
        make_unique<UnitTestingTimedInvokeRequest>(credsIssuerConfig),                      //
        make_unique<UnitTestingTestSimpleOptionalArgumentRequest>(credsIssuerConfig),       //
        make_unique<UnitTestingTestEmitTestEventRequest>(credsIssuerConfig),                //
        make_unique<UnitTestingTestEmitTestFabricScopedEventRequest>(credsIssuerConfig),    //
        make_unique<UnitTestingTestBatchHelperRequest>(credsIssuerConfig),                  //
        make_unique<UnitTestingTestSecondBatchHelperRequest>(credsIssuerConfig),            //
        make_unique<UnitTestingTestDifferentVendorMeiRequest>(credsIssuerConfig),           //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                    //
        make_unique<ReadAttribute>(Id, "boolean", Attributes::Boolean::Id, credsIssuerConfig),                                //
        make_unique<ReadAttribute>(Id, "bitmap8", Attributes::Bitmap8::Id, credsIssuerConfig),                                //
        make_unique<ReadAttribute>(Id, "bitmap16", Attributes::Bitmap16::Id, credsIssuerConfig),                              //
        make_unique<ReadAttribute>(Id, "bitmap32", Attributes::Bitmap32::Id, credsIssuerConfig),                              //
        make_unique<ReadAttribute>(Id, "bitmap64", Attributes::Bitmap64::Id, credsIssuerConfig),                              //
        make_unique<ReadAttribute>(Id, "int8u", Attributes::Int8u::Id, credsIssuerConfig),                                    //
        make_unique<ReadAttribute>(Id, "int16u", Attributes::Int16u::Id, credsIssuerConfig),                                  //
        make_unique<ReadAttribute>(Id, "int24u", Attributes::Int24u::Id, credsIssuerConfig),                                  //
        make_unique<ReadAttribute>(Id, "int32u", Attributes::Int32u::Id, credsIssuerConfig),                                  //
        make_unique<ReadAttribute>(Id, "int40u", Attributes::Int40u::Id, credsIssuerConfig),                                  //
        make_unique<ReadAttribute>(Id, "int48u", Attributes::Int48u::Id, credsIssuerConfig),                                  //
        make_unique<ReadAttribute>(Id, "int56u", Attributes::Int56u::Id, credsIssuerConfig),                                  //
        make_unique<ReadAttribute>(Id, "int64u", Attributes::Int64u::Id, credsIssuerConfig),                                  //
        make_unique<ReadAttribute>(Id, "int8s", Attributes::Int8s::Id, credsIssuerConfig),                                    //
        make_unique<ReadAttribute>(Id, "int16s", Attributes::Int16s::Id, credsIssuerConfig),                                  //
        make_unique<ReadAttribute>(Id, "int24s", Attributes::Int24s::Id, credsIssuerConfig),                                  //
        make_unique<ReadAttribute>(Id, "int32s", Attributes::Int32s::Id, credsIssuerConfig),                                  //
        make_unique<ReadAttribute>(Id, "int40s", Attributes::Int40s::Id, credsIssuerConfig),                                  //
        make_unique<ReadAttribute>(Id, "int48s", Attributes::Int48s::Id, credsIssuerConfig),                                  //
        make_unique<ReadAttribute>(Id, "int56s", Attributes::Int56s::Id, credsIssuerConfig),                                  //
        make_unique<ReadAttribute>(Id, "int64s", Attributes::Int64s::Id, credsIssuerConfig),                                  //
        make_unique<ReadAttribute>(Id, "enum8", Attributes::Enum8::Id, credsIssuerConfig),                                    //
        make_unique<ReadAttribute>(Id, "enum16", Attributes::Enum16::Id, credsIssuerConfig),                                  //
        make_unique<ReadAttribute>(Id, "float-single", Attributes::FloatSingle::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "float-double", Attributes::FloatDouble::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "octet-string", Attributes::OctetString::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "list-int8u", Attributes::ListInt8u::Id, credsIssuerConfig),                           //
        make_unique<ReadAttribute>(Id, "list-octet-string", Attributes::ListOctetString::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "list-struct-octet-string", Attributes::ListStructOctetString::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "long-octet-string", Attributes::LongOctetString::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "char-string", Attributes::CharString::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "long-char-string", Attributes::LongCharString::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "epoch-us", Attributes::EpochUs::Id, credsIssuerConfig),                               //
        make_unique<ReadAttribute>(Id, "epoch-s", Attributes::EpochS::Id, credsIssuerConfig),                                 //
        make_unique<ReadAttribute>(Id, "vendor-id", Attributes::VendorId::Id, credsIssuerConfig),                             //
        make_unique<ReadAttribute>(Id, "list-nullables-and-optionals-struct", Attributes::ListNullablesAndOptionalsStruct::Id,
                                   credsIssuerConfig),                                                                       //
        make_unique<ReadAttribute>(Id, "enum-attr", Attributes::EnumAttr::Id, credsIssuerConfig),                            //
        make_unique<ReadAttribute>(Id, "struct-attr", Attributes::StructAttr::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "range-restricted-int8u", Attributes::RangeRestrictedInt8u::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "range-restricted-int8s", Attributes::RangeRestrictedInt8s::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "range-restricted-int16u", Attributes::RangeRestrictedInt16u::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "range-restricted-int16s", Attributes::RangeRestrictedInt16s::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "list-long-octet-string", Attributes::ListLongOctetString::Id, credsIssuerConfig),    //
        make_unique<ReadAttribute>(Id, "list-fabric-scoped", Attributes::ListFabricScoped::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "timed-write-boolean", Attributes::TimedWriteBoolean::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "general-error-boolean", Attributes::GeneralErrorBoolean::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "cluster-error-boolean", Attributes::ClusterErrorBoolean::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "unsupported", Attributes::Unsupported::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "nullable-boolean", Attributes::NullableBoolean::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "nullable-bitmap8", Attributes::NullableBitmap8::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "nullable-bitmap16", Attributes::NullableBitmap16::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "nullable-bitmap32", Attributes::NullableBitmap32::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "nullable-bitmap64", Attributes::NullableBitmap64::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "nullable-int8u", Attributes::NullableInt8u::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "nullable-int16u", Attributes::NullableInt16u::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "nullable-int24u", Attributes::NullableInt24u::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "nullable-int32u", Attributes::NullableInt32u::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "nullable-int40u", Attributes::NullableInt40u::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "nullable-int48u", Attributes::NullableInt48u::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "nullable-int56u", Attributes::NullableInt56u::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "nullable-int64u", Attributes::NullableInt64u::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "nullable-int8s", Attributes::NullableInt8s::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "nullable-int16s", Attributes::NullableInt16s::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "nullable-int24s", Attributes::NullableInt24s::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "nullable-int32s", Attributes::NullableInt32s::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "nullable-int40s", Attributes::NullableInt40s::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "nullable-int48s", Attributes::NullableInt48s::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "nullable-int56s", Attributes::NullableInt56s::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "nullable-int64s", Attributes::NullableInt64s::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "nullable-enum8", Attributes::NullableEnum8::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "nullable-enum16", Attributes::NullableEnum16::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "nullable-float-single", Attributes::NullableFloatSingle::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "nullable-float-double", Attributes::NullableFloatDouble::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "nullable-octet-string", Attributes::NullableOctetString::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "nullable-char-string", Attributes::NullableCharString::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "nullable-enum-attr", Attributes::NullableEnumAttr::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "nullable-struct", Attributes::NullableStruct::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "nullable-range-restricted-int8u", Attributes::NullableRangeRestrictedInt8u::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "nullable-range-restricted-int8s", Attributes::NullableRangeRestrictedInt8s::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "nullable-range-restricted-int16u", Attributes::NullableRangeRestrictedInt16u::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "nullable-range-restricted-int16s", Attributes::NullableRangeRestrictedInt16s::Id,
                                   credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "write-only-int8u", Attributes::WriteOnlyInt8u::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "mei-int8u", Attributes::MeiInt8u::Id, credsIssuerConfig),                          //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<bool>>(Id, "boolean", 0, 1, Attributes::Boolean::Id, WriteCommandType::kWrite,
                                          credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>>>(
            Id, "bitmap8", 0, UINT8_MAX, Attributes::Bitmap8::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap>>>(
            Id, "bitmap16", 0, UINT16_MAX, Attributes::Bitmap16::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap>>>(
            Id, "bitmap32", 0, UINT32_MAX, Attributes::Bitmap32::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap>>>(
            Id, "bitmap64", 0, UINT64_MAX, Attributes::Bitmap64::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "int8u", 0, UINT8_MAX, Attributes::Int8u::Id, WriteCommandType::kWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "int16u", 0, UINT16_MAX, Attributes::Int16u::Id, WriteCommandType::kWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "int24u", 0, UINT32_MAX, Attributes::Int24u::Id, WriteCommandType::kWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "int32u", 0, UINT32_MAX, Attributes::Int32u::Id, WriteCommandType::kWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint64_t>>(Id, "int40u", 0, UINT64_MAX, Attributes::Int40u::Id, WriteCommandType::kWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint64_t>>(Id, "int48u", 0, UINT64_MAX, Attributes::Int48u::Id, WriteCommandType::kWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint64_t>>(Id, "int56u", 0, UINT64_MAX, Attributes::Int56u::Id, WriteCommandType::kWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint64_t>>(Id, "int64u", 0, UINT64_MAX, Attributes::Int64u::Id, WriteCommandType::kWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<int8_t>>(Id, "int8s", INT8_MIN, INT8_MAX, Attributes::Int8s::Id, WriteCommandType::kWrite,
                                            credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "int16s", INT16_MIN, INT16_MAX, Attributes::Int16s::Id, WriteCommandType::kWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int32_t>>(Id, "int24s", INT32_MIN, INT32_MAX, Attributes::Int24s::Id, WriteCommandType::kWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int32_t>>(Id, "int32s", INT32_MIN, INT32_MAX, Attributes::Int32s::Id, WriteCommandType::kWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int64_t>>(Id, "int40s", INT64_MIN, INT64_MAX, Attributes::Int40s::Id, WriteCommandType::kWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int64_t>>(Id, "int48s", INT64_MIN, INT64_MAX, Attributes::Int48s::Id, WriteCommandType::kWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int64_t>>(Id, "int56s", INT64_MIN, INT64_MAX, Attributes::Int56s::Id, WriteCommandType::kWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<int64_t>>(Id, "int64s", INT64_MIN, INT64_MAX, Attributes::Int64s::Id, WriteCommandType::kWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "enum8", 0, UINT8_MAX, Attributes::Enum8::Id, WriteCommandType::kWrite,
                                             credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "enum16", 0, UINT16_MAX, Attributes::Enum16::Id, WriteCommandType::kWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<float>>(Id, "float-single", -std::numeric_limits<float>::infinity(),
                                           std::numeric_limits<float>::infinity(), Attributes::FloatSingle::Id,
                                           WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<double>>(Id, "float-double", -std::numeric_limits<double>::infinity(),
                                            std::numeric_limits<double>::infinity(), Attributes::FloatDouble::Id,
                                            WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::ByteSpan>>(Id, "octet-string", Attributes::OctetString::Id, WriteCommandType::kWrite,
                                                    credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const uint8_t>>>(
            Id, "list-int8u", Attributes::ListInt8u::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::ByteSpan>>>(
            Id, "list-octet-string", Attributes::ListOctetString::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::UnitTesting::Structs::TestListStructOctet::Type>>>(
            Id, "list-struct-octet-string", Attributes::ListStructOctetString::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::ByteSpan>>(Id, "long-octet-string", Attributes::LongOctetString::Id,
                                                    WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "char-string", Attributes::CharString::Id, WriteCommandType::kWrite,
                                                    credsIssuerConfig), //
        make_unique<WriteAttribute<chip::CharSpan>>(Id, "long-char-string", Attributes::LongCharString::Id,
                                                    WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint64_t>>(Id, "epoch-us", 0, UINT64_MAX, Attributes::EpochUs::Id, WriteCommandType::kWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "epoch-s", 0, UINT32_MAX, Attributes::EpochS::Id, WriteCommandType::kWrite,
                                              credsIssuerConfig), //
        make_unique<WriteAttribute<chip::VendorId>>(Id, "vendor-id", 0, UINT16_MAX, Attributes::VendorId::Id,
                                                    WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::UnitTesting::Structs::NullablesAndOptionalsStruct::Type>>>(
            Id, "list-nullables-and-optionals-struct", Attributes::ListNullablesAndOptionalsStruct::Id, WriteCommandType::kWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::Clusters::UnitTesting::SimpleEnum>>(
            Id, "enum-attr", 0, UINT8_MAX, Attributes::EnumAttr::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::Clusters::UnitTesting::Structs::SimpleStruct::Type>>(
            Id, "struct-attr", Attributes::StructAttr::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "range-restricted-int8u", 0, UINT8_MAX, Attributes::RangeRestrictedInt8u::Id,
                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int8_t>>(Id, "range-restricted-int8s", INT8_MIN, INT8_MAX, Attributes::RangeRestrictedInt8s::Id,
                                            WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "range-restricted-int16u", 0, UINT16_MAX, Attributes::RangeRestrictedInt16u::Id,
                                              WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<int16_t>>(Id, "range-restricted-int16s", INT16_MIN, INT16_MAX,
                                             Attributes::RangeRestrictedInt16s::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::ByteSpan>>>(
            Id, "list-long-octet-string", Attributes::ListLongOctetString::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<
            chip::app::DataModel::List<const chip::app::Clusters::UnitTesting::Structs::TestFabricScoped::Type>>>(
            Id, "list-fabric-scoped", Attributes::ListFabricScoped::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<bool>>(Id, "timed-write-boolean", 0, 1, Attributes::TimedWriteBoolean::Id,
                                          WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<bool>>(Id, "general-error-boolean", 0, 1, Attributes::GeneralErrorBoolean::Id,
                                          WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<bool>>(Id, "cluster-error-boolean", 0, 1, Attributes::ClusterErrorBoolean::Id,
                                          WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<bool>>(Id, "unsupported", 0, 1, Attributes::Unsupported::Id, WriteCommandType::kWrite,
                                          credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<bool>>>(
            Id, "nullable-boolean", 0, 1, Attributes::NullableBoolean::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<
            WriteAttribute<chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap8MaskMap>>>>(
            Id, "nullable-bitmap8", 0, UINT8_MAX, Attributes::NullableBitmap8::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<
            WriteAttribute<chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap16MaskMap>>>>(
            Id, "nullable-bitmap16", 0, UINT16_MAX, Attributes::NullableBitmap16::Id, WriteCommandType::kWrite,
            credsIssuerConfig), //
        make_unique<
            WriteAttribute<chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap32MaskMap>>>>(
            Id, "nullable-bitmap32", 0, UINT32_MAX, Attributes::NullableBitmap32::Id, WriteCommandType::kWrite,
            credsIssuerConfig), //
        make_unique<
            WriteAttribute<chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::UnitTesting::Bitmap64MaskMap>>>>(
            Id, "nullable-bitmap64", 0, UINT64_MAX, Attributes::NullableBitmap64::Id, WriteCommandType::kWrite,
            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(
            Id, "nullable-int8u", 0, UINT8_MAX, Attributes::NullableInt8u::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint16_t>>>(
            Id, "nullable-int16u", 0, UINT16_MAX, Attributes::NullableInt16u::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(
            Id, "nullable-int24u", 0, UINT32_MAX, Attributes::NullableInt24u::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint32_t>>>(
            Id, "nullable-int32u", 0, UINT32_MAX, Attributes::NullableInt32u::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint64_t>>>(
            Id, "nullable-int40u", 0, UINT64_MAX, Attributes::NullableInt40u::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint64_t>>>(
            Id, "nullable-int48u", 0, UINT64_MAX, Attributes::NullableInt48u::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint64_t>>>(
            Id, "nullable-int56u", 0, UINT64_MAX, Attributes::NullableInt56u::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint64_t>>>(
            Id, "nullable-int64u", 0, UINT64_MAX, Attributes::NullableInt64u::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int8_t>>>(Id, "nullable-int8s", INT8_MIN, INT8_MAX,
                                                                            Attributes::NullableInt8s::Id, WriteCommandType::kWrite,
                                                                            credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int16_t>>>(Id, "nullable-int16s", INT16_MIN, INT16_MAX,
                                                                             Attributes::NullableInt16s::Id,
                                                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int32_t>>>(Id, "nullable-int24s", INT32_MIN, INT32_MAX,
                                                                             Attributes::NullableInt24s::Id,
                                                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int32_t>>>(Id, "nullable-int32s", INT32_MIN, INT32_MAX,
                                                                             Attributes::NullableInt32s::Id,
                                                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int64_t>>>(Id, "nullable-int40s", INT64_MIN, INT64_MAX,
                                                                             Attributes::NullableInt40s::Id,
                                                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int64_t>>>(Id, "nullable-int48s", INT64_MIN, INT64_MAX,
                                                                             Attributes::NullableInt48s::Id,
                                                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int64_t>>>(Id, "nullable-int56s", INT64_MIN, INT64_MAX,
                                                                             Attributes::NullableInt56s::Id,
                                                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int64_t>>>(Id, "nullable-int64s", INT64_MIN, INT64_MAX,
                                                                             Attributes::NullableInt64s::Id,
                                                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(
            Id, "nullable-enum8", 0, UINT8_MAX, Attributes::NullableEnum8::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint16_t>>>(
            Id, "nullable-enum16", 0, UINT16_MAX, Attributes::NullableEnum16::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<float>>>(
            Id, "nullable-float-single", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
            Attributes::NullableFloatSingle::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<double>>>(
            Id, "nullable-float-double", -std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity(),
            Attributes::NullableFloatDouble::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::ByteSpan>>>(
            Id, "nullable-octet-string", Attributes::NullableOctetString::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::CharSpan>>>(
            Id, "nullable-char-string", Attributes::NullableCharString::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<chip::app::Clusters::UnitTesting::SimpleEnum>>>(
            Id, "nullable-enum-attr", 0, UINT8_MAX, Attributes::NullableEnumAttr::Id, WriteCommandType::kWrite,
            credsIssuerConfig), //
        make_unique<
            WriteAttributeAsComplex<chip::app::DataModel::Nullable<chip::app::Clusters::UnitTesting::Structs::SimpleStruct::Type>>>(
            Id, "nullable-struct", Attributes::NullableStruct::Id, WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint8_t>>>(Id, "nullable-range-restricted-int8u", 0, UINT8_MAX,
                                                                             Attributes::NullableRangeRestrictedInt8u::Id,
                                                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int8_t>>>(Id, "nullable-range-restricted-int8s", INT8_MIN,
                                                                            INT8_MAX, Attributes::NullableRangeRestrictedInt8s::Id,
                                                                            WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<uint16_t>>>(Id, "nullable-range-restricted-int16u", 0, UINT16_MAX,
                                                                              Attributes::NullableRangeRestrictedInt16u::Id,
                                                                              WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<chip::app::DataModel::Nullable<int16_t>>>(
            Id, "nullable-range-restricted-int16s", INT16_MIN, INT16_MAX, Attributes::NullableRangeRestrictedInt16s::Id,
            WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "write-only-int8u", 0, UINT8_MAX, Attributes::WriteOnlyInt8u::Id,
                                             WriteCommandType::kWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint8_t>>(Id, "mei-int8u", 0, UINT8_MAX, Attributes::MeiInt8u::Id, WriteCommandType::kWrite,
                                             credsIssuerConfig),                                                      //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                       //
        make_unique<SubscribeAttribute>(Id, "boolean", Attributes::Boolean::Id, credsIssuerConfig),                   //
        make_unique<SubscribeAttribute>(Id, "bitmap8", Attributes::Bitmap8::Id, credsIssuerConfig),                   //
        make_unique<SubscribeAttribute>(Id, "bitmap16", Attributes::Bitmap16::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "bitmap32", Attributes::Bitmap32::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "bitmap64", Attributes::Bitmap64::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "int8u", Attributes::Int8u::Id, credsIssuerConfig),                       //
        make_unique<SubscribeAttribute>(Id, "int16u", Attributes::Int16u::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "int24u", Attributes::Int24u::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "int32u", Attributes::Int32u::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "int40u", Attributes::Int40u::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "int48u", Attributes::Int48u::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "int56u", Attributes::Int56u::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "int64u", Attributes::Int64u::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "int8s", Attributes::Int8s::Id, credsIssuerConfig),                       //
        make_unique<SubscribeAttribute>(Id, "int16s", Attributes::Int16s::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "int24s", Attributes::Int24s::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "int32s", Attributes::Int32s::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "int40s", Attributes::Int40s::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "int48s", Attributes::Int48s::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "int56s", Attributes::Int56s::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "int64s", Attributes::Int64s::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "enum8", Attributes::Enum8::Id, credsIssuerConfig),                       //
        make_unique<SubscribeAttribute>(Id, "enum16", Attributes::Enum16::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "float-single", Attributes::FloatSingle::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "float-double", Attributes::FloatDouble::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "octet-string", Attributes::OctetString::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "list-int8u", Attributes::ListInt8u::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "list-octet-string", Attributes::ListOctetString::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "list-struct-octet-string", Attributes::ListStructOctetString::Id,
                                        credsIssuerConfig),                                                           //
        make_unique<SubscribeAttribute>(Id, "long-octet-string", Attributes::LongOctetString::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "char-string", Attributes::CharString::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "long-char-string", Attributes::LongCharString::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "epoch-us", Attributes::EpochUs::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "epoch-s", Attributes::EpochS::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "vendor-id", Attributes::VendorId::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "list-nullables-and-optionals-struct", Attributes::ListNullablesAndOptionalsStruct::Id,
                                        credsIssuerConfig),                                                                       //
        make_unique<SubscribeAttribute>(Id, "enum-attr", Attributes::EnumAttr::Id, credsIssuerConfig),                            //
        make_unique<SubscribeAttribute>(Id, "struct-attr", Attributes::StructAttr::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "range-restricted-int8u", Attributes::RangeRestrictedInt8u::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "range-restricted-int8s", Attributes::RangeRestrictedInt8s::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "range-restricted-int16u", Attributes::RangeRestrictedInt16u::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "range-restricted-int16s", Attributes::RangeRestrictedInt16s::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "list-long-octet-string", Attributes::ListLongOctetString::Id, credsIssuerConfig),    //
        make_unique<SubscribeAttribute>(Id, "list-fabric-scoped", Attributes::ListFabricScoped::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "timed-write-boolean", Attributes::TimedWriteBoolean::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "general-error-boolean", Attributes::GeneralErrorBoolean::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-error-boolean", Attributes::ClusterErrorBoolean::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "unsupported", Attributes::Unsupported::Id, credsIssuerConfig),                       //
        make_unique<SubscribeAttribute>(Id, "nullable-boolean", Attributes::NullableBoolean::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "nullable-bitmap8", Attributes::NullableBitmap8::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "nullable-bitmap16", Attributes::NullableBitmap16::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "nullable-bitmap32", Attributes::NullableBitmap32::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "nullable-bitmap64", Attributes::NullableBitmap64::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "nullable-int8u", Attributes::NullableInt8u::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "nullable-int16u", Attributes::NullableInt16u::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "nullable-int24u", Attributes::NullableInt24u::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "nullable-int32u", Attributes::NullableInt32u::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "nullable-int40u", Attributes::NullableInt40u::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "nullable-int48u", Attributes::NullableInt48u::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "nullable-int56u", Attributes::NullableInt56u::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "nullable-int64u", Attributes::NullableInt64u::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "nullable-int8s", Attributes::NullableInt8s::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "nullable-int16s", Attributes::NullableInt16s::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "nullable-int24s", Attributes::NullableInt24s::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "nullable-int32s", Attributes::NullableInt32s::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "nullable-int40s", Attributes::NullableInt40s::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "nullable-int48s", Attributes::NullableInt48s::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "nullable-int56s", Attributes::NullableInt56s::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "nullable-int64s", Attributes::NullableInt64s::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "nullable-enum8", Attributes::NullableEnum8::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "nullable-enum16", Attributes::NullableEnum16::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "nullable-float-single", Attributes::NullableFloatSingle::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "nullable-float-double", Attributes::NullableFloatDouble::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "nullable-octet-string", Attributes::NullableOctetString::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "nullable-char-string", Attributes::NullableCharString::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "nullable-enum-attr", Attributes::NullableEnumAttr::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "nullable-struct", Attributes::NullableStruct::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "nullable-range-restricted-int8u", Attributes::NullableRangeRestrictedInt8u::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "nullable-range-restricted-int8s", Attributes::NullableRangeRestrictedInt8s::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "nullable-range-restricted-int16u", Attributes::NullableRangeRestrictedInt16u::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "nullable-range-restricted-int16s", Attributes::NullableRangeRestrictedInt16s::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "write-only-int8u", Attributes::WriteOnlyInt8u::Id, credsIssuerConfig),             //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "mei-int8u", Attributes::MeiInt8u::Id, credsIssuerConfig),                          //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                                //
        make_unique<ReadEvent>(Id, "test-event", Events::TestEvent::Id, credsIssuerConfig),                           //
        make_unique<ReadEvent>(Id, "test-fabric-scoped-event", Events::TestFabricScopedEvent::Id, credsIssuerConfig), //
        make_unique<ReadEvent>(Id, "test-different-vendor-mei-event", Events::TestDifferentVendorMeiEvent::Id,
                               credsIssuerConfig),                                                                         //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                                //
        make_unique<SubscribeEvent>(Id, "test-event", Events::TestEvent::Id, credsIssuerConfig),                           //
        make_unique<SubscribeEvent>(Id, "test-fabric-scoped-event", Events::TestFabricScopedEvent::Id, credsIssuerConfig), //
        make_unique<SubscribeEvent>(Id, "test-different-vendor-mei-event", Events::TestDifferentVendorMeiEvent::Id,
                                    credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterFaultInjection(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::FaultInjection;

    const char * clusterName = "FaultInjection";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                //
        make_unique<FaultInjectionFailAtFault>(credsIssuerConfig),         //
        make_unique<FaultInjectionFailRandomlyAtFault>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}
void registerClusterSampleMei(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::SampleMei;

    const char * clusterName = "SampleMei";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),    //
        make_unique<SampleMeiPing>(credsIssuerConfig),         //
        make_unique<SampleMeiAddArguments>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "flip-flop", Attributes::FlipFlop::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute<>>(Id, credsIssuerConfig),                                                              //
        make_unique<WriteAttribute<bool>>(Id, "flip-flop", 0, 1, Attributes::FlipFlop::Id, WriteCommandType::kWrite,
                                          credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite,
            credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::CommandId>>>(
            Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::EventId>>>(
            Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttributeAsComplex<chip::app::DataModel::List<const chip::AttributeId>>>(
            Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint32_t>>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig), //
        make_unique<WriteAttribute<uint16_t>>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id,
                                              WriteCommandType::kForceWrite, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "flip-flop", Attributes::FlipFlop::Id, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                      //
        make_unique<ReadEvent>(Id, "ping-count-event", Events::PingCountEvent::Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                 //
        make_unique<SubscribeEvent>(Id, "ping-count-event", Events::PingCountEvent::Id, credsIssuerConfig), //
    };

    commands.RegisterCluster(clusterName, clusterCommands);
}

void registerClusterAny(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    const char * clusterName = "Any";

    commands_list clusterCommands = {
        make_unique<ClusterCommand>(credsIssuerConfig),     //
        make_unique<ReadAttribute>(credsIssuerConfig),      //
        make_unique<WriteAttribute<>>(credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(credsIssuerConfig), //
        make_unique<ReadEvent>(credsIssuerConfig),          //
        make_unique<SubscribeEvent>(credsIssuerConfig),     //
        make_unique<ReadNone>(credsIssuerConfig),           //
        make_unique<ReadAll>(credsIssuerConfig),            //
        make_unique<SubscribeNone>(credsIssuerConfig),      //
        make_unique<SubscribeAll>(credsIssuerConfig),       //
    };

    commands.RegisterCommandSet(clusterName, clusterCommands,
                                "Commands for sending IM messages based on cluster id, not cluster name.");
}

void registerClusters(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    registerClusterAny(commands, credsIssuerConfig);
    registerClusterIdentify(commands, credsIssuerConfig);
    registerClusterGroups(commands, credsIssuerConfig);
    registerClusterOnOff(commands, credsIssuerConfig);
    registerClusterOnOffSwitchConfiguration(commands, credsIssuerConfig);
    registerClusterLevelControl(commands, credsIssuerConfig);
    registerClusterBinaryInputBasic(commands, credsIssuerConfig);
    registerClusterPulseWidthModulation(commands, credsIssuerConfig);
    registerClusterDescriptor(commands, credsIssuerConfig);
    registerClusterBinding(commands, credsIssuerConfig);
    registerClusterAccessControl(commands, credsIssuerConfig);
    registerClusterActions(commands, credsIssuerConfig);
    registerClusterBasicInformation(commands, credsIssuerConfig);
    registerClusterOtaSoftwareUpdateProvider(commands, credsIssuerConfig);
    registerClusterOtaSoftwareUpdateRequestor(commands, credsIssuerConfig);
    registerClusterLocalizationConfiguration(commands, credsIssuerConfig);
    registerClusterTimeFormatLocalization(commands, credsIssuerConfig);
    registerClusterUnitLocalization(commands, credsIssuerConfig);
    registerClusterPowerSourceConfiguration(commands, credsIssuerConfig);
    registerClusterPowerSource(commands, credsIssuerConfig);
    registerClusterGeneralCommissioning(commands, credsIssuerConfig);
    registerClusterNetworkCommissioning(commands, credsIssuerConfig);
    registerClusterDiagnosticLogs(commands, credsIssuerConfig);
    registerClusterGeneralDiagnostics(commands, credsIssuerConfig);
    registerClusterSoftwareDiagnostics(commands, credsIssuerConfig);
    registerClusterThreadNetworkDiagnostics(commands, credsIssuerConfig);
    registerClusterWiFiNetworkDiagnostics(commands, credsIssuerConfig);
    registerClusterEthernetNetworkDiagnostics(commands, credsIssuerConfig);
    registerClusterTimeSynchronization(commands, credsIssuerConfig);
    registerClusterBridgedDeviceBasicInformation(commands, credsIssuerConfig);
    registerClusterSwitch(commands, credsIssuerConfig);
    registerClusterAdministratorCommissioning(commands, credsIssuerConfig);
    registerClusterOperationalCredentials(commands, credsIssuerConfig);
    registerClusterGroupKeyManagement(commands, credsIssuerConfig);
    registerClusterFixedLabel(commands, credsIssuerConfig);
    registerClusterUserLabel(commands, credsIssuerConfig);
    registerClusterProxyConfiguration(commands, credsIssuerConfig);
    registerClusterProxyDiscovery(commands, credsIssuerConfig);
    registerClusterProxyValid(commands, credsIssuerConfig);
    registerClusterBooleanState(commands, credsIssuerConfig);
    registerClusterIcdManagement(commands, credsIssuerConfig);
    registerClusterTimer(commands, credsIssuerConfig);
    registerClusterOvenCavityOperationalState(commands, credsIssuerConfig);
    registerClusterOvenMode(commands, credsIssuerConfig);
    registerClusterLaundryDryerControls(commands, credsIssuerConfig);
    registerClusterModeSelect(commands, credsIssuerConfig);
    registerClusterLaundryWasherMode(commands, credsIssuerConfig);
    registerClusterRefrigeratorAndTemperatureControlledCabinetMode(commands, credsIssuerConfig);
    registerClusterLaundryWasherControls(commands, credsIssuerConfig);
    registerClusterRvcRunMode(commands, credsIssuerConfig);
    registerClusterRvcCleanMode(commands, credsIssuerConfig);
    registerClusterTemperatureControl(commands, credsIssuerConfig);
    registerClusterRefrigeratorAlarm(commands, credsIssuerConfig);
    registerClusterDishwasherMode(commands, credsIssuerConfig);
    registerClusterAirQuality(commands, credsIssuerConfig);
    registerClusterSmokeCoAlarm(commands, credsIssuerConfig);
    registerClusterDishwasherAlarm(commands, credsIssuerConfig);
    registerClusterMicrowaveOvenMode(commands, credsIssuerConfig);
    registerClusterMicrowaveOvenControl(commands, credsIssuerConfig);
    registerClusterOperationalState(commands, credsIssuerConfig);
    registerClusterRvcOperationalState(commands, credsIssuerConfig);
    registerClusterScenesManagement(commands, credsIssuerConfig);
    registerClusterHepaFilterMonitoring(commands, credsIssuerConfig);
    registerClusterActivatedCarbonFilterMonitoring(commands, credsIssuerConfig);
    registerClusterBooleanStateConfiguration(commands, credsIssuerConfig);
    registerClusterValveConfigurationAndControl(commands, credsIssuerConfig);
    registerClusterElectricalPowerMeasurement(commands, credsIssuerConfig);
    registerClusterElectricalEnergyMeasurement(commands, credsIssuerConfig);
    registerClusterDemandResponseLoadControl(commands, credsIssuerConfig);
    registerClusterMessages(commands, credsIssuerConfig);
    registerClusterDeviceEnergyManagement(commands, credsIssuerConfig);
    registerClusterEnergyEvse(commands, credsIssuerConfig);
    registerClusterEnergyPreference(commands, credsIssuerConfig);
    registerClusterPowerTopology(commands, credsIssuerConfig);
    registerClusterEnergyEvseMode(commands, credsIssuerConfig);
    registerClusterDeviceEnergyManagementMode(commands, credsIssuerConfig);
    registerClusterDoorLock(commands, credsIssuerConfig);
    registerClusterWindowCovering(commands, credsIssuerConfig);
    registerClusterBarrierControl(commands, credsIssuerConfig);
    registerClusterPumpConfigurationAndControl(commands, credsIssuerConfig);
    registerClusterThermostat(commands, credsIssuerConfig);
    registerClusterFanControl(commands, credsIssuerConfig);
    registerClusterThermostatUserInterfaceConfiguration(commands, credsIssuerConfig);
    registerClusterColorControl(commands, credsIssuerConfig);
    registerClusterBallastConfiguration(commands, credsIssuerConfig);
    registerClusterIlluminanceMeasurement(commands, credsIssuerConfig);
    registerClusterTemperatureMeasurement(commands, credsIssuerConfig);
    registerClusterPressureMeasurement(commands, credsIssuerConfig);
    registerClusterFlowMeasurement(commands, credsIssuerConfig);
    registerClusterRelativeHumidityMeasurement(commands, credsIssuerConfig);
    registerClusterOccupancySensing(commands, credsIssuerConfig);
    registerClusterCarbonMonoxideConcentrationMeasurement(commands, credsIssuerConfig);
    registerClusterCarbonDioxideConcentrationMeasurement(commands, credsIssuerConfig);
    registerClusterNitrogenDioxideConcentrationMeasurement(commands, credsIssuerConfig);
    registerClusterOzoneConcentrationMeasurement(commands, credsIssuerConfig);
    registerClusterPm25ConcentrationMeasurement(commands, credsIssuerConfig);
    registerClusterFormaldehydeConcentrationMeasurement(commands, credsIssuerConfig);
    registerClusterPm1ConcentrationMeasurement(commands, credsIssuerConfig);
    registerClusterPm10ConcentrationMeasurement(commands, credsIssuerConfig);
    registerClusterTotalVolatileOrganicCompoundsConcentrationMeasurement(commands, credsIssuerConfig);
    registerClusterRadonConcentrationMeasurement(commands, credsIssuerConfig);
    registerClusterWakeOnLan(commands, credsIssuerConfig);
    registerClusterChannel(commands, credsIssuerConfig);
    registerClusterTargetNavigator(commands, credsIssuerConfig);
    registerClusterMediaPlayback(commands, credsIssuerConfig);
    registerClusterMediaInput(commands, credsIssuerConfig);
    registerClusterLowPower(commands, credsIssuerConfig);
    registerClusterKeypadInput(commands, credsIssuerConfig);
    registerClusterContentLauncher(commands, credsIssuerConfig);
    registerClusterAudioOutput(commands, credsIssuerConfig);
    registerClusterApplicationLauncher(commands, credsIssuerConfig);
    registerClusterApplicationBasic(commands, credsIssuerConfig);
    registerClusterAccountLogin(commands, credsIssuerConfig);
    registerClusterContentControl(commands, credsIssuerConfig);
    registerClusterContentAppObserver(commands, credsIssuerConfig);
    registerClusterElectricalMeasurement(commands, credsIssuerConfig);
    registerClusterUnitTesting(commands, credsIssuerConfig);
    registerClusterFaultInjection(commands, credsIssuerConfig);
    registerClusterSampleMei(commands, credsIssuerConfig);
}