text: /*
   *
   *    Copyright (c) 2021 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
  
  #include <core/CHIPCore.h>
  
  #include <app/CommandSender.h>
  #include <app/InteractionModelEngine.h>
  #include <lib/support/Span.h>
  
  #include <controller/CHIPClusters.h>
  #include <controller/CHIPDevice.h>
  
  using namespace chip;
  using namespace chip::app;
  
  extern "C" {
  
  // Cluster ApplicationBasic
  // End of Cluster ApplicationBasic
  
  // Cluster BarrierControl
  CHIP_ERROR chip_ime_AppendCommand_BarrierControl_BarrierControlGoToPercent(chip::Controller::Device * device,
                                                                             chip::EndpointId ZCLendpointId, chip::GroupId ZCLgroupId,
                                                                             uint8_t percentOpen)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::BarrierControlCluster clusterBarrierControl;
      (void) ZCLgroupId;
      clusterBarrierControl.Associate(device, ZCLendpointId);
      return clusterBarrierControl.BarrierControlGoToPercent(nullptr, nullptr, percentOpen);
  }
  CHIP_ERROR chip_ime_AppendCommand_BarrierControl_BarrierControlStop(chip::Controller::Device * device,
                                                                      chip::EndpointId ZCLendpointId, chip::GroupId ZCLgroupId)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::BarrierControlCluster clusterBarrierControl;
      (void) ZCLgroupId;
      clusterBarrierControl.Associate(device, ZCLendpointId);
      return clusterBarrierControl.BarrierControlStop(nullptr, nullptr);
  }
  // End of Cluster BarrierControl
  
  // Cluster Basic
  CHIP_ERROR chip_ime_AppendCommand_Basic_MfgSpecificPing(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                          chip::GroupId ZCLgroupId)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::BasicCluster clusterBasic;
      (void) ZCLgroupId;
      clusterBasic.Associate(device, ZCLendpointId);
      return clusterBasic.MfgSpecificPing(nullptr, nullptr);
  }
  // End of Cluster Basic
  
  // Cluster Binding
  CHIP_ERROR chip_ime_AppendCommand_Binding_Bind(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                 chip::GroupId ZCLgroupId, chip::NodeId nodeId, chip::GroupId groupId,
                                                 chip::EndpointId endpointId, chip::ClusterId clusterId)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::BindingCluster clusterBinding;
      (void) ZCLgroupId;
      clusterBinding.Associate(device, ZCLendpointId);
      return clusterBinding.Bind(nullptr, nullptr, nodeId, groupId, endpointId, clusterId);
  }
  CHIP_ERROR chip_ime_AppendCommand_Binding_Unbind(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                   chip::GroupId ZCLgroupId, chip::NodeId nodeId, chip::GroupId groupId,
                                                   chip::EndpointId endpointId, chip::ClusterId clusterId)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::BindingCluster clusterBinding;
      (void) ZCLgroupId;
      clusterBinding.Associate(device, ZCLendpointId);
      return clusterBinding.Unbind(nullptr, nullptr, nodeId, groupId, endpointId, clusterId);
  }
  // End of Cluster Binding
  
  // Cluster ColorControl
  CHIP_ERROR chip_ime_AppendCommand_ColorControl_MoveColor(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                           chip::GroupId ZCLgroupId, int16_t rateX, int16_t rateY,
                                                           uint8_t optionsMask, uint8_t optionsOverride)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::ColorControlCluster clusterColorControl;
      (void) ZCLgroupId;
      clusterColorControl.Associate(device, ZCLendpointId);
      return clusterColorControl.MoveColor(nullptr, nullptr, rateX, rateY, optionsMask, optionsOverride);
  }
  CHIP_ERROR chip_ime_AppendCommand_ColorControl_MoveColorTemperature(
      chip::Controller::Device * device, chip::EndpointId ZCLendpointId, chip::GroupId ZCLgroupId, uint8_t moveMode, uint16_t rate,
      uint16_t colorTemperatureMinimum, uint16_t colorTemperatureMaximum, uint8_t optionsMask, uint8_t optionsOverride)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::ColorControlCluster clusterColorControl;
      (void) ZCLgroupId;
      clusterColorControl.Associate(device, ZCLendpointId);
      return clusterColorControl.MoveColorTemperature(nullptr, nullptr, moveMode, rate, colorTemperatureMinimum,
                                                      colorTemperatureMaximum, optionsMask, optionsOverride);
  }
  CHIP_ERROR chip_ime_AppendCommand_ColorControl_MoveHue(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                         chip::GroupId ZCLgroupId, uint8_t moveMode, uint8_t rate,
                                                         uint8_t optionsMask, uint8_t optionsOverride)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::ColorControlCluster clusterColorControl;
      (void) ZCLgroupId;
      clusterColorControl.Associate(device, ZCLendpointId);
      return clusterColorControl.MoveHue(nullptr, nullptr, moveMode, rate, optionsMask, optionsOverride);
  }
  CHIP_ERROR chip_ime_AppendCommand_ColorControl_MoveSaturation(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                                chip::GroupId ZCLgroupId, uint8_t moveMode, uint8_t rate,
                                                                uint8_t optionsMask, uint8_t optionsOverride)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::ColorControlCluster clusterColorControl;
      (void) ZCLgroupId;
      clusterColorControl.Associate(device, ZCLendpointId);
      return clusterColorControl.MoveSaturation(nullptr, nullptr, moveMode, rate, optionsMask, optionsOverride);
  }
  CHIP_ERROR chip_ime_AppendCommand_ColorControl_MoveToColor(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                             chip::GroupId ZCLgroupId, uint16_t colorX, uint16_t colorY,
                                                             uint16_t transitionTime, uint8_t optionsMask, uint8_t optionsOverride)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::ColorControlCluster clusterColorControl;
      (void) ZCLgroupId;
      clusterColorControl.Associate(device, ZCLendpointId);
      return clusterColorControl.MoveToColor(nullptr, nullptr, colorX, colorY, transitionTime, optionsMask, optionsOverride);
  }
  CHIP_ERROR chip_ime_AppendCommand_ColorControl_MoveToColorTemperature(chip::Controller::Device * device,
                                                                        chip::EndpointId ZCLendpointId, chip::GroupId ZCLgroupId,
                                                                        uint16_t colorTemperature, uint16_t transitionTime,
                                                                        uint8_t optionsMask, uint8_t optionsOverride)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::ColorControlCluster clusterColorControl;
      (void) ZCLgroupId;
      clusterColorControl.Associate(device, ZCLendpointId);
      return clusterColorControl.MoveToColorTemperature(nullptr, nullptr, colorTemperature, transitionTime, optionsMask,
                                                        optionsOverride);
  }
  CHIP_ERROR chip_ime_AppendCommand_ColorControl_MoveToHue(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                           chip::GroupId ZCLgroupId, uint8_t hue, uint8_t direction,
                                                           uint16_t transitionTime, uint8_t optionsMask, uint8_t optionsOverride)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::ColorControlCluster clusterColorControl;
      (void) ZCLgroupId;
      clusterColorControl.Associate(device, ZCLendpointId);
      return clusterColorControl.MoveToHue(nullptr, nullptr, hue, direction, transitionTime, optionsMask, optionsOverride);
  }
  CHIP_ERROR chip_ime_AppendCommand_ColorControl_MoveToHueAndSaturation(chip::Controller::Device * device,
                                                                        chip::EndpointId ZCLendpointId, chip::GroupId ZCLgroupId,
                                                                        uint8_t hue, uint8_t saturation, uint16_t transitionTime,
                                                                        uint8_t optionsMask, uint8_t optionsOverride)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::ColorControlCluster clusterColorControl;
      (void) ZCLgroupId;
      clusterColorControl.Associate(device, ZCLendpointId);
      return clusterColorControl.MoveToHueAndSaturation(nullptr, nullptr, hue, saturation, transitionTime, optionsMask,
                                                        optionsOverride);
  }
  CHIP_ERROR chip_ime_AppendCommand_ColorControl_MoveToSaturation(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                                  chip::GroupId ZCLgroupId, uint8_t saturation,
                                                                  uint16_t transitionTime, uint8_t optionsMask,
                                                                  uint8_t optionsOverride)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::ColorControlCluster clusterColorControl;
      (void) ZCLgroupId;
      clusterColorControl.Associate(device, ZCLendpointId);
      return clusterColorControl.MoveToSaturation(nullptr, nullptr, saturation, transitionTime, optionsMask, optionsOverride);
  }
  CHIP_ERROR chip_ime_AppendCommand_ColorControl_StepColor(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                           chip::GroupId ZCLgroupId, int16_t stepX, int16_t stepY,
                                                           uint16_t transitionTime, uint8_t optionsMask, uint8_t optionsOverride)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::ColorControlCluster clusterColorControl;
      (void) ZCLgroupId;
      clusterColorControl.Associate(device, ZCLendpointId);
      return clusterColorControl.StepColor(nullptr, nullptr, stepX, stepY, transitionTime, optionsMask, optionsOverride);
  }
  CHIP_ERROR chip_ime_AppendCommand_ColorControl_StepColorTemperature(chip::Controller::Device * device,
                                                                      chip::EndpointId ZCLendpointId, chip::GroupId ZCLgroupId,
                                                                      uint8_t stepMode, uint16_t stepSize, uint16_t transitionTime,
                                                                      uint16_t colorTemperatureMinimum,
                                                                      uint16_t colorTemperatureMaximum, uint8_t optionsMask,
                                                                      uint8_t optionsOverride)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::ColorControlCluster clusterColorControl;
      (void) ZCLgroupId;
      clusterColorControl.Associate(device, ZCLendpointId);
      return clusterColorControl.StepColorTemperature(nullptr, nullptr, stepMode, stepSize, transitionTime, colorTemperatureMinimum,
                                                      colorTemperatureMaximum, optionsMask, optionsOverride);
  }
  CHIP_ERROR chip_ime_AppendCommand_ColorControl_StepHue(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                         chip::GroupId ZCLgroupId, uint8_t stepMode, uint8_t stepSize,
                                                         uint8_t transitionTime, uint8_t optionsMask, uint8_t optionsOverride)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::ColorControlCluster clusterColorControl;
      (void) ZCLgroupId;
      clusterColorControl.Associate(device, ZCLendpointId);
      return clusterColorControl.StepHue(nullptr, nullptr, stepMode, stepSize, transitionTime, optionsMask, optionsOverride);
  }
  CHIP_ERROR chip_ime_AppendCommand_ColorControl_StepSaturation(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                                chip::GroupId ZCLgroupId, uint8_t stepMode, uint8_t stepSize,
                                                                uint8_t transitionTime, uint8_t optionsMask, uint8_t optionsOverride)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::ColorControlCluster clusterColorControl;
      (void) ZCLgroupId;
      clusterColorControl.Associate(device, ZCLendpointId);
      return clusterColorControl.StepSaturation(nullptr, nullptr, stepMode, stepSize, transitionTime, optionsMask, optionsOverride);
  }
  CHIP_ERROR chip_ime_AppendCommand_ColorControl_StopMoveStep(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                              chip::GroupId ZCLgroupId, uint8_t optionsMask, uint8_t optionsOverride)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::ColorControlCluster clusterColorControl;
      (void) ZCLgroupId;
      clusterColorControl.Associate(device, ZCLendpointId);
      return clusterColorControl.StopMoveStep(nullptr, nullptr, optionsMask, optionsOverride);
  }
  // End of Cluster ColorControl
  
  // Cluster DoorLock
  CHIP_ERROR chip_ime_AppendCommand_DoorLock_ClearAllPins(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                          chip::GroupId ZCLgroupId)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::DoorLockCluster clusterDoorLock;
      (void) ZCLgroupId;
      clusterDoorLock.Associate(device, ZCLendpointId);
      return clusterDoorLock.ClearAllPins(nullptr, nullptr);
  }
  CHIP_ERROR chip_ime_AppendCommand_DoorLock_ClearAllRfids(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                           chip::GroupId ZCLgroupId)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::DoorLockCluster clusterDoorLock;
      (void) ZCLgroupId;
      clusterDoorLock.Associate(device, ZCLendpointId);
      return clusterDoorLock.ClearAllRfids(nullptr, nullptr);
  }
  CHIP_ERROR chip_ime_AppendCommand_DoorLock_ClearHolidaySchedule(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                                  chip::GroupId ZCLgroupId, uint8_t scheduleId)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::DoorLockCluster clusterDoorLock;
      (void) ZCLgroupId;
      clusterDoorLock.Associate(device, ZCLendpointId);
      return clusterDoorLock.ClearHolidaySchedule(nullptr, nullptr, scheduleId);
  }
  CHIP_ERROR chip_ime_AppendCommand_DoorLock_ClearPin(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                      chip::GroupId ZCLgroupId, uint16_t userId)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::DoorLockCluster clusterDoorLock;
      (void) ZCLgroupId;
      clusterDoorLock.Associate(device, ZCLendpointId);
      return clusterDoorLock.ClearPin(nullptr, nullptr, userId);
  }
  CHIP_ERROR chip_ime_AppendCommand_DoorLock_ClearRfid(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                       chip::GroupId ZCLgroupId, uint16_t userId)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::DoorLockCluster clusterDoorLock;
      (void) ZCLgroupId;
      clusterDoorLock.Associate(device, ZCLendpointId);
      return clusterDoorLock.ClearRfid(nullptr, nullptr, userId);
  }
  CHIP_ERROR chip_ime_AppendCommand_DoorLock_ClearWeekdaySchedule(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                                  chip::GroupId ZCLgroupId, uint8_t scheduleId, uint16_t userId)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::DoorLockCluster clusterDoorLock;
      (void) ZCLgroupId;
      clusterDoorLock.Associate(device, ZCLendpointId);
      return clusterDoorLock.ClearWeekdaySchedule(nullptr, nullptr, scheduleId, userId);
  }
  CHIP_ERROR chip_ime_AppendCommand_DoorLock_ClearYeardaySchedule(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                                  chip::GroupId ZCLgroupId, uint8_t scheduleId, uint16_t userId)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::DoorLockCluster clusterDoorLock;
      (void) ZCLgroupId;
      clusterDoorLock.Associate(device, ZCLendpointId);
      return clusterDoorLock.ClearYeardaySchedule(nullptr, nullptr, scheduleId, userId);
  }
  CHIP_ERROR chip_ime_AppendCommand_DoorLock_GetHolidaySchedule(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                                chip::GroupId ZCLgroupId, uint8_t scheduleId)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::DoorLockCluster clusterDoorLock;
      (void) ZCLgroupId;
      clusterDoorLock.Associate(device, ZCLendpointId);
      return clusterDoorLock.GetHolidaySchedule(nullptr, nullptr, scheduleId);
  }
  CHIP_ERROR chip_ime_AppendCommand_DoorLock_GetLogRecord(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                          chip::GroupId ZCLgroupId, uint16_t logIndex)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::DoorLockCluster clusterDoorLock;
      (void) ZCLgroupId;
      clusterDoorLock.Associate(device, ZCLendpointId);
      return clusterDoorLock.GetLogRecord(nullptr, nullptr, logIndex);
  }
  CHIP_ERROR chip_ime_AppendCommand_DoorLock_GetPin(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                    chip::GroupId ZCLgroupId, uint16_t userId)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::DoorLockCluster clusterDoorLock;
      (void) ZCLgroupId;
      clusterDoorLock.Associate(device, ZCLendpointId);
      return clusterDoorLock.GetPin(nullptr, nullptr, userId);
  }
  CHIP_ERROR chip_ime_AppendCommand_DoorLock_GetRfid(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                     chip::GroupId ZCLgroupId, uint16_t userId)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::DoorLockCluster clusterDoorLock;
      (void) ZCLgroupId;
      clusterDoorLock.Associate(device, ZCLendpointId);
      return clusterDoorLock.GetRfid(nullptr, nullptr, userId);
  }
  CHIP_ERROR chip_ime_AppendCommand_DoorLock_GetUserType(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                         chip::GroupId ZCLgroupId, uint16_t userId)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::DoorLockCluster clusterDoorLock;
      (void) ZCLgroupId;
      clusterDoorLock.Associate(device, ZCLendpointId);
      return clusterDoorLock.GetUserType(nullptr, nullptr, userId);
  }
  CHIP_ERROR chip_ime_AppendCommand_DoorLock_GetWeekdaySchedule(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                                chip::GroupId ZCLgroupId, uint8_t scheduleId, uint16_t userId)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::DoorLockCluster clusterDoorLock;
      (void) ZCLgroupId;
      clusterDoorLock.Associate(device, ZCLendpointId);
      return clusterDoorLock.GetWeekdaySchedule(nullptr, nullptr, scheduleId, userId);
  }
  CHIP_ERROR chip_ime_AppendCommand_DoorLock_GetYeardaySchedule(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                                chip::GroupId ZCLgroupId, uint8_t scheduleId, uint16_t userId)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::DoorLockCluster clusterDoorLock;
      (void) ZCLgroupId;
      clusterDoorLock.Associate(device, ZCLendpointId);
      return clusterDoorLock.GetYeardaySchedule(nullptr, nullptr, scheduleId, userId);
  }
  CHIP_ERROR chip_ime_AppendCommand_DoorLock_LockDoor(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                      chip::GroupId ZCLgroupId, const uint8_t * pin, uint32_t pin_Len)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::DoorLockCluster clusterDoorLock;
      (void) ZCLgroupId;
      clusterDoorLock.Associate(device, ZCLendpointId);
      return clusterDoorLock.LockDoor(nullptr, nullptr, chip::ByteSpan(pin, pin_Len));
  }
  CHIP_ERROR chip_ime_AppendCommand_DoorLock_SetHolidaySchedule(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                                chip::GroupId ZCLgroupId, uint8_t scheduleId, uint32_t localStartTime,
                                                                uint32_t localEndTime, uint8_t operatingModeDuringHoliday)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::DoorLockCluster clusterDoorLock;
      (void) ZCLgroupId;
      clusterDoorLock.Associate(device, ZCLendpointId);
      return clusterDoorLock.SetHolidaySchedule(nullptr, nullptr, scheduleId, localStartTime, localEndTime,
                                                operatingModeDuringHoliday);
  }
  CHIP_ERROR chip_ime_AppendCommand_DoorLock_SetPin(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                    chip::GroupId ZCLgroupId, uint16_t userId, uint8_t userStatus, uint8_t userType,
                                                    const uint8_t * pin, uint32_t pin_Len)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::DoorLockCluster clusterDoorLock;
      (void) ZCLgroupId;
      clusterDoorLock.Associate(device, ZCLendpointId);
      return clusterDoorLock.SetPin(nullptr, nullptr, userId, userStatus, userType, chip::ByteSpan(pin, pin_Len));
  }
  CHIP_ERROR chip_ime_AppendCommand_DoorLock_SetRfid(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                     chip::GroupId ZCLgroupId, uint16_t userId, uint8_t userStatus, uint8_t userType,
                                                     const uint8_t * id, uint32_t id_Len)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::DoorLockCluster clusterDoorLock;
      (void) ZCLgroupId;
      clusterDoorLock.Associate(device, ZCLendpointId);
      return clusterDoorLock.SetRfid(nullptr, nullptr, userId, userStatus, userType, chip::ByteSpan(id, id_Len));
  }
  CHIP_ERROR chip_ime_AppendCommand_DoorLock_SetUserType(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                         chip::GroupId ZCLgroupId, uint16_t userId, uint8_t userType)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::DoorLockCluster clusterDoorLock;
      (void) ZCLgroupId;
      clusterDoorLock.Associate(device, ZCLendpointId);
      return clusterDoorLock.SetUserType(nullptr, nullptr, userId, userType);
  }
  CHIP_ERROR chip_ime_AppendCommand_DoorLock_SetWeekdaySchedule(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                                chip::GroupId ZCLgroupId, uint8_t scheduleId, uint16_t userId,
                                                                uint8_t daysMask, uint8_t startHour, uint8_t startMinute,
                                                                uint8_t endHour, uint8_t endMinute)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::DoorLockCluster clusterDoorLock;
      (void) ZCLgroupId;
      clusterDoorLock.Associate(device, ZCLendpointId);
      return clusterDoorLock.SetWeekdaySchedule(nullptr, nullptr, scheduleId, userId, daysMask, startHour, startMinute, endHour,
                                                endMinute);
  }
  CHIP_ERROR chip_ime_AppendCommand_DoorLock_SetYeardaySchedule(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                                chip::GroupId ZCLgroupId, uint8_t scheduleId, uint16_t userId,
                                                                uint32_t localStartTime, uint32_t localEndTime)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::DoorLockCluster clusterDoorLock;
      (void) ZCLgroupId;
      clusterDoorLock.Associate(device, ZCLendpointId);
      return clusterDoorLock.SetYeardaySchedule(nullptr, nullptr, scheduleId, userId, localStartTime, localEndTime);
  }
  CHIP_ERROR chip_ime_AppendCommand_DoorLock_UnlockDoor(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                        chip::GroupId ZCLgroupId, const uint8_t * pin, uint32_t pin_Len)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::DoorLockCluster clusterDoorLock;
      (void) ZCLgroupId;
      clusterDoorLock.Associate(device, ZCLendpointId);
      return clusterDoorLock.UnlockDoor(nullptr, nullptr, chip::ByteSpan(pin, pin_Len));
  }
  CHIP_ERROR chip_ime_AppendCommand_DoorLock_UnlockWithTimeout(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                               chip::GroupId ZCLgroupId, uint16_t timeoutInSeconds,
                                                               const uint8_t * pin, uint32_t pin_Len)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::DoorLockCluster clusterDoorLock;
      (void) ZCLgroupId;
      clusterDoorLock.Associate(device, ZCLendpointId);
      return clusterDoorLock.UnlockWithTimeout(nullptr, nullptr, timeoutInSeconds, chip::ByteSpan(pin, pin_Len));
  }
  // End of Cluster DoorLock
  
  // Cluster GeneralCommissioning
  CHIP_ERROR chip_ime_AppendCommand_GeneralCommissioning_ArmFailSafe(chip::Controller::Device * device,
                                                                     chip::EndpointId ZCLendpointId, chip::GroupId ZCLgroupId,
                                                                     uint16_t expiryLengthSeconds, uint64_t breadcrumb,
                                                                     uint32_t timeoutMs)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::GeneralCommissioningCluster clusterGeneralCommissioning;
      (void) ZCLgroupId;
      clusterGeneralCommissioning.Associate(device, ZCLendpointId);
      return clusterGeneralCommissioning.ArmFailSafe(nullptr, nullptr, expiryLengthSeconds, breadcrumb, timeoutMs);
  }
  CHIP_ERROR chip_ime_AppendCommand_GeneralCommissioning_CommissioningComplete(chip::Controller::Device * device,
                                                                               chip::EndpointId ZCLendpointId,
                                                                               chip::GroupId ZCLgroupId)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::GeneralCommissioningCluster clusterGeneralCommissioning;
      (void) ZCLgroupId;
      clusterGeneralCommissioning.Associate(device, ZCLendpointId);
      return clusterGeneralCommissioning.CommissioningComplete(nullptr, nullptr);
  }
  CHIP_ERROR chip_ime_AppendCommand_GeneralCommissioning_SetFabric(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                                   chip::GroupId ZCLgroupId, const uint8_t * fabricId,
                                                                   uint32_t fabricId_Len, const uint8_t * fabricSecret,
                                                                   uint32_t fabricSecret_Len, uint64_t breadcrumb, uint32_t timeoutMs)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::GeneralCommissioningCluster clusterGeneralCommissioning;
      (void) ZCLgroupId;
      clusterGeneralCommissioning.Associate(device, ZCLendpointId);
      return clusterGeneralCommissioning.SetFabric(nullptr, nullptr, chip::ByteSpan(fabricId, fabricId_Len),
                                                   chip::ByteSpan(fabricSecret, fabricSecret_Len), breadcrumb, timeoutMs);
  }
  // End of Cluster GeneralCommissioning
  
  // Cluster GroupKeyManagement
  // End of Cluster GroupKeyManagement
  
  // Cluster Groups
  CHIP_ERROR chip_ime_AppendCommand_Groups_AddGroup(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                    chip::GroupId ZCLgroupId, uint16_t groupId, const uint8_t * groupName,
                                                    uint32_t groupName_Len)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::GroupsCluster clusterGroups;
      (void) ZCLgroupId;
      clusterGroups.Associate(device, ZCLendpointId);
      return clusterGroups.AddGroup(nullptr, nullptr, groupId, chip::ByteSpan(groupName, groupName_Len));
  }
  CHIP_ERROR chip_ime_AppendCommand_Groups_AddGroupIfIdentifying(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                                 chip::GroupId ZCLgroupId, uint16_t groupId,
                                                                 const uint8_t * groupName, uint32_t groupName_Len)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::GroupsCluster clusterGroups;
      (void) ZCLgroupId;
      clusterGroups.Associate(device, ZCLendpointId);
      return clusterGroups.AddGroupIfIdentifying(nullptr, nullptr, groupId, chip::ByteSpan(groupName, groupName_Len));
  }
  CHIP_ERROR chip_ime_AppendCommand_Groups_GetGroupMembership(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                              chip::GroupId ZCLgroupId, uint8_t groupCount, uint16_t groupList)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::GroupsCluster clusterGroups;
      (void) ZCLgroupId;
      clusterGroups.Associate(device, ZCLendpointId);
      return clusterGroups.GetGroupMembership(nullptr, nullptr, groupCount, groupList);
  }
  CHIP_ERROR chip_ime_AppendCommand_Groups_RemoveAllGroups(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                           chip::GroupId ZCLgroupId)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::GroupsCluster clusterGroups;
      (void) ZCLgroupId;
      clusterGroups.Associate(device, ZCLendpointId);
      return clusterGroups.RemoveAllGroups(nullptr, nullptr);
  }
  CHIP_ERROR chip_ime_AppendCommand_Groups_RemoveGroup(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                       chip::GroupId ZCLgroupId, uint16_t groupId)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::GroupsCluster clusterGroups;
      (void) ZCLgroupId;
      clusterGroups.Associate(device, ZCLendpointId);
      return clusterGroups.RemoveGroup(nullptr, nullptr, groupId);
  }
  CHIP_ERROR chip_ime_AppendCommand_Groups_ViewGroup(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                     chip::GroupId ZCLgroupId, uint16_t groupId)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::GroupsCluster clusterGroups;
      (void) ZCLgroupId;
      clusterGroups.Associate(device, ZCLendpointId);
      return clusterGroups.ViewGroup(nullptr, nullptr, groupId);
  }
  // End of Cluster Groups
  
  // Cluster IasZone
  // End of Cluster IasZone
  
  // Cluster Identify
  CHIP_ERROR chip_ime_AppendCommand_Identify_Identify(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                      chip::GroupId ZCLgroupId, uint16_t identifyTime)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::IdentifyCluster clusterIdentify;
      (void) ZCLgroupId;
      clusterIdentify.Associate(device, ZCLendpointId);
      return clusterIdentify.Identify(nullptr, nullptr, identifyTime);
  }
  CHIP_ERROR chip_ime_AppendCommand_Identify_IdentifyQuery(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                           chip::GroupId ZCLgroupId)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::IdentifyCluster clusterIdentify;
      (void) ZCLgroupId;
      clusterIdentify.Associate(device, ZCLendpointId);
      return clusterIdentify.IdentifyQuery(nullptr, nullptr);
  }
  // End of Cluster Identify
  
  // Cluster LevelControl
  CHIP_ERROR chip_ime_AppendCommand_LevelControl_Move(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                      chip::GroupId ZCLgroupId, uint8_t moveMode, uint8_t rate, uint8_t optionMask,
                                                      uint8_t optionOverride)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::LevelControlCluster clusterLevelControl;
      (void) ZCLgroupId;
      clusterLevelControl.Associate(device, ZCLendpointId);
      return clusterLevelControl.Move(nullptr, nullptr, moveMode, rate, optionMask, optionOverride);
  }
  CHIP_ERROR chip_ime_AppendCommand_LevelControl_MoveToLevel(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                             chip::GroupId ZCLgroupId, uint8_t level, uint16_t transitionTime,
                                                             uint8_t optionMask, uint8_t optionOverride)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::LevelControlCluster clusterLevelControl;
      (void) ZCLgroupId;
      clusterLevelControl.Associate(device, ZCLendpointId);
      return clusterLevelControl.MoveToLevel(nullptr, nullptr, level, transitionTime, optionMask, optionOverride);
  }
  CHIP_ERROR chip_ime_AppendCommand_LevelControl_MoveToLevelWithOnOff(chip::Controller::Device * device,
                                                                      chip::EndpointId ZCLendpointId, chip::GroupId ZCLgroupId,
                                                                      uint8_t level, uint16_t transitionTime)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::LevelControlCluster clusterLevelControl;
      (void) ZCLgroupId;
      clusterLevelControl.Associate(device, ZCLendpointId);
      return clusterLevelControl.MoveToLevelWithOnOff(nullptr, nullptr, level, transitionTime);
  }
  CHIP_ERROR chip_ime_AppendCommand_LevelControl_MoveWithOnOff(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                               chip::GroupId ZCLgroupId, uint8_t moveMode, uint8_t rate)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::LevelControlCluster clusterLevelControl;
      (void) ZCLgroupId;
      clusterLevelControl.Associate(device, ZCLendpointId);
      return clusterLevelControl.MoveWithOnOff(nullptr, nullptr, moveMode, rate);
  }
  CHIP_ERROR chip_ime_AppendCommand_LevelControl_Step(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                      chip::GroupId ZCLgroupId, uint8_t stepMode, uint8_t stepSize,
                                                      uint16_t transitionTime, uint8_t optionMask, uint8_t optionOverride)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::LevelControlCluster clusterLevelControl;
      (void) ZCLgroupId;
      clusterLevelControl.Associate(device, ZCLendpointId);
      return clusterLevelControl.Step(nullptr, nullptr, stepMode, stepSize, transitionTime, optionMask, optionOverride);
  }
  CHIP_ERROR chip_ime_AppendCommand_LevelControl_StepWithOnOff(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                               chip::GroupId ZCLgroupId, uint8_t stepMode, uint8_t stepSize,
                                                               uint16_t transitionTime)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::LevelControlCluster clusterLevelControl;
      (void) ZCLgroupId;
      clusterLevelControl.Associate(device, ZCLendpointId);
      return clusterLevelControl.StepWithOnOff(nullptr, nullptr, stepMode, stepSize, transitionTime);
  }
  CHIP_ERROR chip_ime_AppendCommand_LevelControl_Stop(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                      chip::GroupId ZCLgroupId, uint8_t optionMask, uint8_t optionOverride)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::LevelControlCluster clusterLevelControl;
      (void) ZCLgroupId;
      clusterLevelControl.Associate(device, ZCLendpointId);
      return clusterLevelControl.Stop(nullptr, nullptr, optionMask, optionOverride);
  }
  CHIP_ERROR chip_ime_AppendCommand_LevelControl_StopWithOnOff(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                               chip::GroupId ZCLgroupId)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::LevelControlCluster clusterLevelControl;
      (void) ZCLgroupId;
      clusterLevelControl.Associate(device, ZCLendpointId);
      return clusterLevelControl.StopWithOnOff(nullptr, nullptr);
  }
  // End of Cluster LevelControl
  
  // Cluster LowPower
  CHIP_ERROR chip_ime_AppendCommand_LowPower_Sleep(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                   chip::GroupId ZCLgroupId)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::LowPowerCluster clusterLowPower;
      (void) ZCLgroupId;
      clusterLowPower.Associate(device, ZCLendpointId);
      return clusterLowPower.Sleep(nullptr, nullptr);
  }
  // End of Cluster LowPower
  
  // Cluster NetworkCommissioning
  CHIP_ERROR chip_ime_AppendCommand_NetworkCommissioning_AddThreadNetwork(chip::Controller::Device * device,
                                                                          chip::EndpointId ZCLendpointId, chip::GroupId ZCLgroupId,
                                                                          const uint8_t * operationalDataset,
                                                                          uint32_t operationalDataset_Len, uint64_t breadcrumb,
                                                                          uint32_t timeoutMs)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::NetworkCommissioningCluster clusterNetworkCommissioning;
      (void) ZCLgroupId;
      clusterNetworkCommissioning.Associate(device, ZCLendpointId);
      return clusterNetworkCommissioning.AddThreadNetwork(
          nullptr, nullptr, chip::ByteSpan(operationalDataset, operationalDataset_Len), breadcrumb, timeoutMs);
  }
  CHIP_ERROR chip_ime_AppendCommand_NetworkCommissioning_AddWiFiNetwork(chip::Controller::Device * device,
                                                                        chip::EndpointId ZCLendpointId, chip::GroupId ZCLgroupId,
                                                                        const uint8_t * ssid, uint32_t ssid_Len,
                                                                        const uint8_t * credentials, uint32_t credentials_Len,
                                                                        uint64_t breadcrumb, uint32_t timeoutMs)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::NetworkCommissioningCluster clusterNetworkCommissioning;
      (void) ZCLgroupId;
      clusterNetworkCommissioning.Associate(device, ZCLendpointId);
      return clusterNetworkCommissioning.AddWiFiNetwork(nullptr, nullptr, chip::ByteSpan(ssid, ssid_Len),
                                                        chip::ByteSpan(credentials, credentials_Len), breadcrumb, timeoutMs);
  }
  CHIP_ERROR chip_ime_AppendCommand_NetworkCommissioning_DisableNetwork(chip::Controller::Device * device,
                                                                        chip::EndpointId ZCLendpointId, chip::GroupId ZCLgroupId,
                                                                        const uint8_t * networkID, uint32_t networkID_Len,
                                                                        uint64_t breadcrumb, uint32_t timeoutMs)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::NetworkCommissioningCluster clusterNetworkCommissioning;
      (void) ZCLgroupId;
      clusterNetworkCommissioning.Associate(device, ZCLendpointId);
      return clusterNetworkCommissioning.DisableNetwork(nullptr, nullptr, chip::ByteSpan(networkID, networkID_Len), breadcrumb,
                                                        timeoutMs);
  }
  CHIP_ERROR chip_ime_AppendCommand_NetworkCommissioning_EnableNetwork(chip::Controller::Device * device,
                                                                       chip::EndpointId ZCLendpointId, chip::GroupId ZCLgroupId,
                                                                       const uint8_t * networkID, uint32_t networkID_Len,
                                                                       uint64_t breadcrumb, uint32_t timeoutMs)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::NetworkCommissioningCluster clusterNetworkCommissioning;
      (void) ZCLgroupId;
      clusterNetworkCommissioning.Associate(device, ZCLendpointId);
      return clusterNetworkCommissioning.EnableNetwork(nullptr, nullptr, chip::ByteSpan(networkID, networkID_Len), breadcrumb,
                                                       timeoutMs);
  }
  CHIP_ERROR chip_ime_AppendCommand_NetworkCommissioning_GetLastNetworkCommissioningResult(chip::Controller::Device * device,
                                                                                           chip::EndpointId ZCLendpointId,
                                                                                           chip::GroupId ZCLgroupId,
                                                                                           uint32_t timeoutMs)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::NetworkCommissioningCluster clusterNetworkCommissioning;
      (void) ZCLgroupId;
      clusterNetworkCommissioning.Associate(device, ZCLendpointId);
      return clusterNetworkCommissioning.GetLastNetworkCommissioningResult(nullptr, nullptr, timeoutMs);
  }
  CHIP_ERROR chip_ime_AppendCommand_NetworkCommissioning_RemoveNetwork(chip::Controller::Device * device,
                                                                       chip::EndpointId ZCLendpointId, chip::GroupId ZCLgroupId,
                                                                       const uint8_t * networkID, uint32_t networkID_Len,
                                                                       uint64_t breadcrumb, uint32_t timeoutMs)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::NetworkCommissioningCluster clusterNetworkCommissioning;
      (void) ZCLgroupId;
      clusterNetworkCommissioning.Associate(device, ZCLendpointId);
      return clusterNetworkCommissioning.RemoveNetwork(nullptr, nullptr, chip::ByteSpan(networkID, networkID_Len), breadcrumb,
                                                       timeoutMs);
  }
  CHIP_ERROR chip_ime_AppendCommand_NetworkCommissioning_ScanNetworks(chip::Controller::Device * device,
                                                                      chip::EndpointId ZCLendpointId, chip::GroupId ZCLgroupId,
                                                                      const uint8_t * ssid, uint32_t ssid_Len, uint64_t breadcrumb,
                                                                      uint32_t timeoutMs)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::NetworkCommissioningCluster clusterNetworkCommissioning;
      (void) ZCLgroupId;
      clusterNetworkCommissioning.Associate(device, ZCLendpointId);
      return clusterNetworkCommissioning.ScanNetworks(nullptr, nullptr, chip::ByteSpan(ssid, ssid_Len), breadcrumb, timeoutMs);
  }
  CHIP_ERROR chip_ime_AppendCommand_NetworkCommissioning_UpdateThreadNetwork(chip::Controller::Device * device,
                                                                             chip::EndpointId ZCLendpointId, chip::GroupId ZCLgroupId,
                                                                             const uint8_t * operationalDataset,
                                                                             uint32_t operationalDataset_Len, uint64_t breadcrumb,
                                                                             uint32_t timeoutMs)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::NetworkCommissioningCluster clusterNetworkCommissioning;
      (void) ZCLgroupId;
      clusterNetworkCommissioning.Associate(device, ZCLendpointId);
      return clusterNetworkCommissioning.UpdateThreadNetwork(
          nullptr, nullptr, chip::ByteSpan(operationalDataset, operationalDataset_Len), breadcrumb, timeoutMs);
  }
  CHIP_ERROR chip_ime_AppendCommand_NetworkCommissioning_UpdateWiFiNetwork(chip::Controller::Device * device,
                                                                           chip::EndpointId ZCLendpointId, chip::GroupId ZCLgroupId,
                                                                           const uint8_t * ssid, uint32_t ssid_Len,
                                                                           const uint8_t * credentials, uint32_t credentials_Len,
                                                                           uint64_t breadcrumb, uint32_t timeoutMs)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::NetworkCommissioningCluster clusterNetworkCommissioning;
      (void) ZCLgroupId;
      clusterNetworkCommissioning.Associate(device, ZCLendpointId);
      return clusterNetworkCommissioning.UpdateWiFiNetwork(nullptr, nullptr, chip::ByteSpan(ssid, ssid_Len),
                                                           chip::ByteSpan(credentials, credentials_Len), breadcrumb, timeoutMs);
  }
  // End of Cluster NetworkCommissioning
  
  // Cluster OnOff
  CHIP_ERROR chip_ime_AppendCommand_OnOff_Off(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                              chip::GroupId ZCLgroupId)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::OnOffCluster clusterOnOff;
      (void) ZCLgroupId;
      clusterOnOff.Associate(device, ZCLendpointId);
      return clusterOnOff.Off(nullptr, nullptr);
  }
  CHIP_ERROR chip_ime_AppendCommand_OnOff_On(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                             chip::GroupId ZCLgroupId)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::OnOffCluster clusterOnOff;
      (void) ZCLgroupId;
      clusterOnOff.Associate(device, ZCLendpointId);
      return clusterOnOff.On(nullptr, nullptr);
  }
  CHIP_ERROR chip_ime_AppendCommand_OnOff_Toggle(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                 chip::GroupId ZCLgroupId)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::OnOffCluster clusterOnOff;
      (void) ZCLgroupId;
      clusterOnOff.Associate(device, ZCLendpointId);
      return clusterOnOff.Toggle(nullptr, nullptr);
  }
  // End of Cluster OnOff
  
  // Cluster Scenes
  CHIP_ERROR chip_ime_AppendCommand_Scenes_AddScene(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                    chip::GroupId ZCLgroupId, uint16_t groupId, uint8_t sceneId,
                                                    uint16_t transitionTime, const uint8_t * sceneName, uint32_t sceneName_Len,
                                                    chip::ClusterId clusterId, uint8_t length, uint8_t value)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::ScenesCluster clusterScenes;
      (void) ZCLgroupId;
      clusterScenes.Associate(device, ZCLendpointId);
      return clusterScenes.AddScene(nullptr, nullptr, groupId, sceneId, transitionTime, chip::ByteSpan(sceneName, sceneName_Len),
                                    clusterId, length, value);
  }
  CHIP_ERROR chip_ime_AppendCommand_Scenes_GetSceneMembership(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                              chip::GroupId ZCLgroupId, uint16_t groupId)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::ScenesCluster clusterScenes;
      (void) ZCLgroupId;
      clusterScenes.Associate(device, ZCLendpointId);
      return clusterScenes.GetSceneMembership(nullptr, nullptr, groupId);
  }
  CHIP_ERROR chip_ime_AppendCommand_Scenes_RecallScene(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                       chip::GroupId ZCLgroupId, uint16_t groupId, uint8_t sceneId,
                                                       uint16_t transitionTime)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::ScenesCluster clusterScenes;
      (void) ZCLgroupId;
      clusterScenes.Associate(device, ZCLendpointId);
      return clusterScenes.RecallScene(nullptr, nullptr, groupId, sceneId, transitionTime);
  }
  CHIP_ERROR chip_ime_AppendCommand_Scenes_RemoveAllScenes(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                           chip::GroupId ZCLgroupId, uint16_t groupId)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::ScenesCluster clusterScenes;
      (void) ZCLgroupId;
      clusterScenes.Associate(device, ZCLendpointId);
      return clusterScenes.RemoveAllScenes(nullptr, nullptr, groupId);
  }
  CHIP_ERROR chip_ime_AppendCommand_Scenes_RemoveScene(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                       chip::GroupId ZCLgroupId, uint16_t groupId, uint8_t sceneId)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::ScenesCluster clusterScenes;
      (void) ZCLgroupId;
      clusterScenes.Associate(device, ZCLendpointId);
      return clusterScenes.RemoveScene(nullptr, nullptr, groupId, sceneId);
  }
  CHIP_ERROR chip_ime_AppendCommand_Scenes_StoreScene(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                      chip::GroupId ZCLgroupId, uint16_t groupId, uint8_t sceneId)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::ScenesCluster clusterScenes;
      (void) ZCLgroupId;
      clusterScenes.Associate(device, ZCLendpointId);
      return clusterScenes.StoreScene(nullptr, nullptr, groupId, sceneId);
  }
  CHIP_ERROR chip_ime_AppendCommand_Scenes_ViewScene(chip::Controller::Device * device, chip::EndpointId ZCLendpointId,
                                                     chip::GroupId ZCLgroupId, uint16_t groupId, uint8_t sceneId)
  {
      VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      chip::Controller::ScenesCluster clusterScenes;
      (void) ZCLgroupId;
      clusterScenes.Associate(device, ZCLendpointId);
      return clusterScenes.ViewScene(nullptr, nullptr, groupId, sceneId);
  }
  // End of Cluster Scenes
  
  // Cluster TemperatureMeasurement
  // End of Cluster TemperatureMeasurement
  }
  