text: /*
   *
   *    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
  
  #include <commands/clusters/ComplexArgument.h>
  
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::AccessControl::Structs::AccessControlEntry::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("AccessControlEntry.privilege", "privilege", value.isMember("privilege")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("AccessControlEntry.authMode", "authMode", value.isMember("authMode")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("AccessControlEntry.subjects", "subjects", value.isMember("subjects")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("AccessControlEntry.targets", "targets", value.isMember("targets")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "privilege");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.privilege, value["privilege"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "authMode");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.authMode, value["authMode"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "subjects");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.subjects, value["subjects"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "targets");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.targets, value["targets"]));
  
      if (value.isMember("fabricIndex"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "fabricIndex");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.fabricIndex, value["fabricIndex"]));
      }
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::AccessControl::Structs::AccessControlEntry::Type & request)
  {
      ComplexArgumentParser::Finalize(request.privilege);
      ComplexArgumentParser::Finalize(request.authMode);
      ComplexArgumentParser::Finalize(request.subjects);
      ComplexArgumentParser::Finalize(request.targets);
      ComplexArgumentParser::Finalize(request.fabricIndex);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::BridgedActions::Structs::ActionStruct::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("ActionStruct.actionID", "actionID", value.isMember("actionID")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("ActionStruct.name", "name", value.isMember("name")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("ActionStruct.type", "type", value.isMember("type")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("ActionStruct.endpointListID", "endpointListID",
                                                                    value.isMember("endpointListID")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("ActionStruct.supportedCommands", "supportedCommands",
                                                                    value.isMember("supportedCommands")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("ActionStruct.status", "status", value.isMember("status")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "actionID");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.actionID, value["actionID"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "name");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.name, value["name"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "type");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.type, value["type"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "endpointListID");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.endpointListID, value["endpointListID"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "supportedCommands");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.supportedCommands, value["supportedCommands"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "status");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.status, value["status"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::BridgedActions::Structs::ActionStruct::Type & request)
  {
      ComplexArgumentParser::Finalize(request.actionID);
      ComplexArgumentParser::Finalize(request.name);
      ComplexArgumentParser::Finalize(request.type);
      ComplexArgumentParser::Finalize(request.endpointListID);
      ComplexArgumentParser::Finalize(request.supportedCommands);
      ComplexArgumentParser::Finalize(request.status);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::ContentLauncher::Structs::AdditionalInfo::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("AdditionalInfo.name", "name", value.isMember("name")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("AdditionalInfo.value", "value", value.isMember("value")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "name");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.name, value["name"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "value");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.value, value["value"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::ContentLauncher::Structs::AdditionalInfo::Type & request)
  {
      ComplexArgumentParser::Finalize(request.name);
      ComplexArgumentParser::Finalize(request.value);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::ApplicationLauncher::Structs::Application::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("Application.catalogVendorId", "catalogVendorId",
                                                                    value.isMember("catalogVendorId")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("Application.applicationId", "applicationId", value.isMember("applicationId")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "catalogVendorId");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.catalogVendorId, value["catalogVendorId"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "applicationId");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.applicationId, value["applicationId"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::ApplicationLauncher::Structs::Application::Type & request)
  {
      ComplexArgumentParser::Finalize(request.catalogVendorId);
      ComplexArgumentParser::Finalize(request.applicationId);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::ApplicationBasic::Structs::ApplicationBasicApplication::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("ApplicationBasicApplication.catalogVendorId", "catalogVendorId",
                                                                    value.isMember("catalogVendorId")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("ApplicationBasicApplication.applicationId", "applicationId",
                                                                    value.isMember("applicationId")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "catalogVendorId");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.catalogVendorId, value["catalogVendorId"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "applicationId");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.applicationId, value["applicationId"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::ApplicationBasic::Structs::ApplicationBasicApplication::Type & request)
  {
      ComplexArgumentParser::Finalize(request.catalogVendorId);
      ComplexArgumentParser::Finalize(request.applicationId);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::ApplicationLauncher::Structs::ApplicationEP::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("ApplicationEP.application", "application", value.isMember("application")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "application");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.application, value["application"]));
  
      if (value.isMember("endpoint"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "endpoint");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.endpoint, value["endpoint"]));
      }
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::ApplicationLauncher::Structs::ApplicationEP::Type & request)
  {
      ComplexArgumentParser::Finalize(request.application);
      ComplexArgumentParser::Finalize(request.endpoint);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::GeneralCommissioning::Structs::BasicCommissioningInfo::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("BasicCommissioningInfo.failSafeExpiryLengthSeconds",
                                                                    "failSafeExpiryLengthSeconds",
                                                                    value.isMember("failSafeExpiryLengthSeconds")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "failSafeExpiryLengthSeconds");
      ReturnErrorOnFailure(
          ComplexArgumentParser::Setup(labelWithMember, request.failSafeExpiryLengthSeconds, value["failSafeExpiryLengthSeconds"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::GeneralCommissioning::Structs::BasicCommissioningInfo::Type & request)
  {
      ComplexArgumentParser::Finalize(request.failSafeExpiryLengthSeconds);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::PowerSource::Structs::BatChargeFaultChangeType::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("BatChargeFaultChangeType.current", "current", value.isMember("current")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("BatChargeFaultChangeType.previous", "previous", value.isMember("previous")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "current");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.current, value["current"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "previous");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.previous, value["previous"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::PowerSource::Structs::BatChargeFaultChangeType::Type & request)
  {
      ComplexArgumentParser::Finalize(request.current);
      ComplexArgumentParser::Finalize(request.previous);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::PowerSource::Structs::BatFaultChangeType::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("BatFaultChangeType.current", "current", value.isMember("current")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("BatFaultChangeType.previous", "previous", value.isMember("previous")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "current");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.current, value["current"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "previous");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.previous, value["previous"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::PowerSource::Structs::BatFaultChangeType::Type & request)
  {
      ComplexArgumentParser::Finalize(request.current);
      ComplexArgumentParser::Finalize(request.previous);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::ContentLauncher::Structs::BrandingInformation::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("BrandingInformation.providerName", "providerName",
                                                                    value.isMember("providerName")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "providerName");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.providerName, value["providerName"]));
  
      if (value.isMember("background"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "background");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.background, value["background"]));
      }
  
      if (value.isMember("logo"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "logo");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.logo, value["logo"]));
      }
  
      if (value.isMember("progressBar"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "progressBar");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.progressBar, value["progressBar"]));
      }
  
      if (value.isMember("splash"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "splash");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.splash, value["splash"]));
      }
  
      if (value.isMember("waterMark"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "waterMark");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.waterMark, value["waterMark"]));
      }
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::ContentLauncher::Structs::BrandingInformation::Type & request)
  {
      ComplexArgumentParser::Finalize(request.providerName);
      ComplexArgumentParser::Finalize(request.background);
      ComplexArgumentParser::Finalize(request.logo);
      ComplexArgumentParser::Finalize(request.progressBar);
      ComplexArgumentParser::Finalize(request.splash);
      ComplexArgumentParser::Finalize(request.waterMark);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::Basic::Structs::CapabilityMinimaStruct::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist(
          "CapabilityMinimaStruct.caseSessionsPerFabric", "caseSessionsPerFabric", value.isMember("caseSessionsPerFabric")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist(
          "CapabilityMinimaStruct.subscriptionsPerFabric", "subscriptionsPerFabric", value.isMember("subscriptionsPerFabric")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "caseSessionsPerFabric");
      ReturnErrorOnFailure(
          ComplexArgumentParser::Setup(labelWithMember, request.caseSessionsPerFabric, value["caseSessionsPerFabric"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "subscriptionsPerFabric");
      ReturnErrorOnFailure(
          ComplexArgumentParser::Setup(labelWithMember, request.subscriptionsPerFabric, value["subscriptionsPerFabric"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::Basic::Structs::CapabilityMinimaStruct::Type & request)
  {
      ComplexArgumentParser::Finalize(request.caseSessionsPerFabric);
      ComplexArgumentParser::Finalize(request.subscriptionsPerFabric);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label, chip::app::Clusters::Channel::Structs::ChannelInfo::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("ChannelInfo.majorNumber", "majorNumber", value.isMember("majorNumber")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("ChannelInfo.minorNumber", "minorNumber", value.isMember("minorNumber")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "majorNumber");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.majorNumber, value["majorNumber"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "minorNumber");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.minorNumber, value["minorNumber"]));
  
      if (value.isMember("name"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "name");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.name, value["name"]));
      }
  
      if (value.isMember("callSign"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "callSign");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.callSign, value["callSign"]));
      }
  
      if (value.isMember("affiliateCallSign"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "affiliateCallSign");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.affiliateCallSign, value["affiliateCallSign"]));
      }
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::Channel::Structs::ChannelInfo::Type & request)
  {
      ComplexArgumentParser::Finalize(request.majorNumber);
      ComplexArgumentParser::Finalize(request.minorNumber);
      ComplexArgumentParser::Finalize(request.name);
      ComplexArgumentParser::Finalize(request.callSign);
      ComplexArgumentParser::Finalize(request.affiliateCallSign);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::ContentLauncher::Structs::ContentSearch::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("ContentSearch.parameterList", "parameterList", value.isMember("parameterList")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "parameterList");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.parameterList, value["parameterList"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::ContentLauncher::Structs::ContentSearch::Type & request)
  {
      ComplexArgumentParser::Finalize(request.parameterList);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label, chip::app::Clusters::Descriptor::Structs::DeviceType::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("DeviceType.type", "type", value.isMember("type")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("DeviceType.revision", "revision", value.isMember("revision")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "type");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.type, value["type"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "revision");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.revision, value["revision"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::Descriptor::Structs::DeviceType::Type & request)
  {
      ComplexArgumentParser::Finalize(request.type);
      ComplexArgumentParser::Finalize(request.revision);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::ContentLauncher::Structs::Dimension::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("Dimension.width", "width", value.isMember("width")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("Dimension.height", "height", value.isMember("height")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("Dimension.metric", "metric", value.isMember("metric")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "width");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.width, value["width"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "height");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.height, value["height"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "metric");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.metric, value["metric"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::ContentLauncher::Structs::Dimension::Type & request)
  {
      ComplexArgumentParser::Finalize(request.width);
      ComplexArgumentParser::Finalize(request.height);
      ComplexArgumentParser::Finalize(request.metric);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label, chip::app::Clusters::DoorLock::Structs::DlCredential::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("DlCredential.credentialType", "credentialType",
                                                                    value.isMember("credentialType")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("DlCredential.credentialIndex", "credentialIndex",
                                                                    value.isMember("credentialIndex")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "credentialType");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.credentialType, value["credentialType"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "credentialIndex");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.credentialIndex, value["credentialIndex"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::DoorLock::Structs::DlCredential::Type & request)
  {
      ComplexArgumentParser::Finalize(request.credentialType);
      ComplexArgumentParser::Finalize(request.credentialIndex);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::TestCluster::Structs::DoubleNestedStructList::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("DoubleNestedStructList.a", "a", value.isMember("a")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "a");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.a, value["a"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::TestCluster::Structs::DoubleNestedStructList::Type & request)
  {
      ComplexArgumentParser::Finalize(request.a);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::BridgedActions::Structs::EndpointListStruct::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("EndpointListStruct.endpointListID", "endpointListID",
                                                                    value.isMember("endpointListID")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("EndpointListStruct.name", "name", value.isMember("name")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("EndpointListStruct.type", "type", value.isMember("type")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("EndpointListStruct.endpoints", "endpoints", value.isMember("endpoints")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "endpointListID");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.endpointListID, value["endpointListID"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "name");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.name, value["name"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "type");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.type, value["type"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "endpoints");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.endpoints, value["endpoints"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::BridgedActions::Structs::EndpointListStruct::Type & request)
  {
      ComplexArgumentParser::Finalize(request.endpointListID);
      ComplexArgumentParser::Finalize(request.name);
      ComplexArgumentParser::Finalize(request.type);
      ComplexArgumentParser::Finalize(request.endpoints);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::AccessControl::Structs::ExtensionEntry::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("ExtensionEntry.data", "data", value.isMember("data")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "data");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.data, value["data"]));
  
      if (value.isMember("fabricIndex"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "fabricIndex");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.fabricIndex, value["fabricIndex"]));
      }
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::AccessControl::Structs::ExtensionEntry::Type & request)
  {
      ComplexArgumentParser::Finalize(request.data);
      ComplexArgumentParser::Finalize(request.fabricIndex);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::OperationalCredentials::Structs::FabricDescriptor::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("FabricDescriptor.rootPublicKey", "rootPublicKey",
                                                                    value.isMember("rootPublicKey")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("FabricDescriptor.vendorId", "vendorId", value.isMember("vendorId")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("FabricDescriptor.fabricId", "fabricId", value.isMember("fabricId")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("FabricDescriptor.nodeId", "nodeId", value.isMember("nodeId")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("FabricDescriptor.label", "label", value.isMember("label")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "rootPublicKey");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.rootPublicKey, value["rootPublicKey"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "vendorId");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.vendorId, value["vendorId"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "fabricId");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.fabricId, value["fabricId"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "nodeId");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.nodeId, value["nodeId"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "label");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.label, value["label"]));
  
      if (value.isMember("fabricIndex"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "fabricIndex");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.fabricIndex, value["fabricIndex"]));
      }
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::OperationalCredentials::Structs::FabricDescriptor::Type & request)
  {
      ComplexArgumentParser::Finalize(request.rootPublicKey);
      ComplexArgumentParser::Finalize(request.vendorId);
      ComplexArgumentParser::Finalize(request.fabricId);
      ComplexArgumentParser::Finalize(request.nodeId);
      ComplexArgumentParser::Finalize(request.label);
      ComplexArgumentParser::Finalize(request.fabricIndex);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::GroupKeyManagement::Structs::GroupInfoMapStruct::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("GroupInfoMapStruct.groupId", "groupId", value.isMember("groupId")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("GroupInfoMapStruct.endpoints", "endpoints", value.isMember("endpoints")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "groupId");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.groupId, value["groupId"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "endpoints");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.endpoints, value["endpoints"]));
  
      if (value.isMember("groupName"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "groupName");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.groupName, value["groupName"]));
      }
  
      if (value.isMember("fabricIndex"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "fabricIndex");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.fabricIndex, value["fabricIndex"]));
      }
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::GroupKeyManagement::Structs::GroupInfoMapStruct::Type & request)
  {
      ComplexArgumentParser::Finalize(request.groupId);
      ComplexArgumentParser::Finalize(request.endpoints);
      ComplexArgumentParser::Finalize(request.groupName);
      ComplexArgumentParser::Finalize(request.fabricIndex);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::GroupKeyManagement::Structs::GroupKeyMapStruct::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("GroupKeyMapStruct.groupId", "groupId", value.isMember("groupId")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("GroupKeyMapStruct.groupKeySetID", "groupKeySetID",
                                                                    value.isMember("groupKeySetID")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "groupId");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.groupId, value["groupId"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "groupKeySetID");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.groupKeySetID, value["groupKeySetID"]));
  
      if (value.isMember("fabricIndex"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "fabricIndex");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.fabricIndex, value["fabricIndex"]));
      }
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::GroupKeyManagement::Structs::GroupKeyMapStruct::Type & request)
  {
      ComplexArgumentParser::Finalize(request.groupId);
      ComplexArgumentParser::Finalize(request.groupKeySetID);
      ComplexArgumentParser::Finalize(request.fabricIndex);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::GroupKeyManagement::Structs::GroupKeySetStruct::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("GroupKeySetStruct.groupKeySetID", "groupKeySetID",
                                                                    value.isMember("groupKeySetID")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist(
          "GroupKeySetStruct.groupKeySecurityPolicy", "groupKeySecurityPolicy", value.isMember("groupKeySecurityPolicy")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("GroupKeySetStruct.epochKey0", "epochKey0", value.isMember("epochKey0")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("GroupKeySetStruct.epochStartTime0", "epochStartTime0",
                                                                    value.isMember("epochStartTime0")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("GroupKeySetStruct.epochKey1", "epochKey1", value.isMember("epochKey1")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("GroupKeySetStruct.epochStartTime1", "epochStartTime1",
                                                                    value.isMember("epochStartTime1")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("GroupKeySetStruct.epochKey2", "epochKey2", value.isMember("epochKey2")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("GroupKeySetStruct.epochStartTime2", "epochStartTime2",
                                                                    value.isMember("epochStartTime2")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "groupKeySetID");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.groupKeySetID, value["groupKeySetID"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "groupKeySecurityPolicy");
      ReturnErrorOnFailure(
          ComplexArgumentParser::Setup(labelWithMember, request.groupKeySecurityPolicy, value["groupKeySecurityPolicy"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "epochKey0");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.epochKey0, value["epochKey0"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "epochStartTime0");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.epochStartTime0, value["epochStartTime0"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "epochKey1");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.epochKey1, value["epochKey1"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "epochStartTime1");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.epochStartTime1, value["epochStartTime1"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "epochKey2");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.epochKey2, value["epochKey2"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "epochStartTime2");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.epochStartTime2, value["epochStartTime2"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::GroupKeyManagement::Structs::GroupKeySetStruct::Type & request)
  {
      ComplexArgumentParser::Finalize(request.groupKeySetID);
      ComplexArgumentParser::Finalize(request.groupKeySecurityPolicy);
      ComplexArgumentParser::Finalize(request.epochKey0);
      ComplexArgumentParser::Finalize(request.epochStartTime0);
      ComplexArgumentParser::Finalize(request.epochKey1);
      ComplexArgumentParser::Finalize(request.epochStartTime1);
      ComplexArgumentParser::Finalize(request.epochKey2);
      ComplexArgumentParser::Finalize(request.epochStartTime2);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::IasAce::Structs::IasAceZoneStatusResult::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("IasAceZoneStatusResult.zoneId", "zoneId", value.isMember("zoneId")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("IasAceZoneStatusResult.zoneStatus", "zoneStatus", value.isMember("zoneStatus")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "zoneId");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.zoneId, value["zoneId"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "zoneStatus");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.zoneStatus, value["zoneStatus"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::IasAce::Structs::IasAceZoneStatusResult::Type & request)
  {
      ComplexArgumentParser::Finalize(request.zoneId);
      ComplexArgumentParser::Finalize(request.zoneStatus);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label, chip::app::Clusters::MediaInput::Structs::InputInfo::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("InputInfo.index", "index", value.isMember("index")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("InputInfo.inputType", "inputType", value.isMember("inputType")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("InputInfo.name", "name", value.isMember("name")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("InputInfo.description", "description", value.isMember("description")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "index");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.index, value["index"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "inputType");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.inputType, value["inputType"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "name");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.name, value["name"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "description");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.description, value["description"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::MediaInput::Structs::InputInfo::Type & request)
  {
      ComplexArgumentParser::Finalize(request.index);
      ComplexArgumentParser::Finalize(request.inputType);
      ComplexArgumentParser::Finalize(request.name);
      ComplexArgumentParser::Finalize(request.description);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label, chip::app::Clusters::detail::Structs::LabelStruct::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("LabelStruct.label", "label", value.isMember("label")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("LabelStruct.value", "value", value.isMember("value")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "label");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.label, value["label"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "value");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.value, value["value"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::detail::Structs::LabelStruct::Type & request)
  {
      ComplexArgumentParser::Finalize(request.label);
      ComplexArgumentParser::Finalize(request.value);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label, chip::app::Clusters::Channel::Structs::LineupInfo::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("LineupInfo.operatorName", "operatorName", value.isMember("operatorName")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("LineupInfo.lineupInfoType", "lineupInfoType", value.isMember("lineupInfoType")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "operatorName");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.operatorName, value["operatorName"]));
  
      if (value.isMember("lineupName"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "lineupName");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.lineupName, value["lineupName"]));
      }
  
      if (value.isMember("postalCode"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "postalCode");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.postalCode, value["postalCode"]));
      }
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "lineupInfoType");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.lineupInfoType, value["lineupInfoType"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::Channel::Structs::LineupInfo::Type & request)
  {
      ComplexArgumentParser::Finalize(request.operatorName);
      ComplexArgumentParser::Finalize(request.lineupName);
      ComplexArgumentParser::Finalize(request.postalCode);
      ComplexArgumentParser::Finalize(request.lineupInfoType);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::ModeSelect::Structs::ModeOptionStruct::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("ModeOptionStruct.label", "label", value.isMember("label")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("ModeOptionStruct.mode", "mode", value.isMember("mode")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("ModeOptionStruct.semanticTags", "semanticTags", value.isMember("semanticTags")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "label");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.label, value["label"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "mode");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.mode, value["mode"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "semanticTags");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.semanticTags, value["semanticTags"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::ModeSelect::Structs::ModeOptionStruct::Type & request)
  {
      ComplexArgumentParser::Finalize(request.label);
      ComplexArgumentParser::Finalize(request.mode);
      ComplexArgumentParser::Finalize(request.semanticTags);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::OperationalCredentials::Structs::NOCStruct::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NOCStruct.noc", "noc", value.isMember("noc")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NOCStruct.icac", "icac", value.isMember("icac")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "noc");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.noc, value["noc"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "icac");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.icac, value["icac"]));
  
      if (value.isMember("fabricIndex"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "fabricIndex");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.fabricIndex, value["fabricIndex"]));
      }
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::OperationalCredentials::Structs::NOCStruct::Type & request)
  {
      ComplexArgumentParser::Finalize(request.noc);
      ComplexArgumentParser::Finalize(request.icac);
      ComplexArgumentParser::Finalize(request.fabricIndex);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::ThreadNetworkDiagnostics::Structs::NeighborTable::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("NeighborTable.extAddress", "extAddress", value.isMember("extAddress")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NeighborTable.age", "age", value.isMember("age")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NeighborTable.rloc16", "rloc16", value.isMember("rloc16")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NeighborTable.linkFrameCounter", "linkFrameCounter",
                                                                    value.isMember("linkFrameCounter")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NeighborTable.mleFrameCounter", "mleFrameCounter",
                                                                    value.isMember("mleFrameCounter")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NeighborTable.lqi", "lqi", value.isMember("lqi")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("NeighborTable.averageRssi", "averageRssi", value.isMember("averageRssi")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("NeighborTable.lastRssi", "lastRssi", value.isMember("lastRssi")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NeighborTable.frameErrorRate", "frameErrorRate",
                                                                    value.isMember("frameErrorRate")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NeighborTable.messageErrorRate", "messageErrorRate",
                                                                    value.isMember("messageErrorRate")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("NeighborTable.rxOnWhenIdle", "rxOnWhenIdle", value.isMember("rxOnWhenIdle")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NeighborTable.fullThreadDevice", "fullThreadDevice",
                                                                    value.isMember("fullThreadDevice")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NeighborTable.fullNetworkData", "fullNetworkData",
                                                                    value.isMember("fullNetworkData")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NeighborTable.isChild", "isChild", value.isMember("isChild")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "extAddress");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.extAddress, value["extAddress"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "age");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.age, value["age"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "rloc16");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.rloc16, value["rloc16"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "linkFrameCounter");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.linkFrameCounter, value["linkFrameCounter"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "mleFrameCounter");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.mleFrameCounter, value["mleFrameCounter"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "lqi");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.lqi, value["lqi"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "averageRssi");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.averageRssi, value["averageRssi"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "lastRssi");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.lastRssi, value["lastRssi"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "frameErrorRate");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.frameErrorRate, value["frameErrorRate"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "messageErrorRate");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.messageErrorRate, value["messageErrorRate"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "rxOnWhenIdle");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.rxOnWhenIdle, value["rxOnWhenIdle"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "fullThreadDevice");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.fullThreadDevice, value["fullThreadDevice"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "fullNetworkData");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.fullNetworkData, value["fullNetworkData"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "isChild");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.isChild, value["isChild"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::ThreadNetworkDiagnostics::Structs::NeighborTable::Type & request)
  {
      ComplexArgumentParser::Finalize(request.extAddress);
      ComplexArgumentParser::Finalize(request.age);
      ComplexArgumentParser::Finalize(request.rloc16);
      ComplexArgumentParser::Finalize(request.linkFrameCounter);
      ComplexArgumentParser::Finalize(request.mleFrameCounter);
      ComplexArgumentParser::Finalize(request.lqi);
      ComplexArgumentParser::Finalize(request.averageRssi);
      ComplexArgumentParser::Finalize(request.lastRssi);
      ComplexArgumentParser::Finalize(request.frameErrorRate);
      ComplexArgumentParser::Finalize(request.messageErrorRate);
      ComplexArgumentParser::Finalize(request.rxOnWhenIdle);
      ComplexArgumentParser::Finalize(request.fullThreadDevice);
      ComplexArgumentParser::Finalize(request.fullNetworkData);
      ComplexArgumentParser::Finalize(request.isChild);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label, chip::app::Clusters::TestCluster::Structs::NestedStruct::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NestedStruct.a", "a", value.isMember("a")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NestedStruct.b", "b", value.isMember("b")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NestedStruct.c", "c", value.isMember("c")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "a");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.a, value["a"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "b");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.b, value["b"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "c");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.c, value["c"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::TestCluster::Structs::NestedStruct::Type & request)
  {
      ComplexArgumentParser::Finalize(request.a);
      ComplexArgumentParser::Finalize(request.b);
      ComplexArgumentParser::Finalize(request.c);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::TestCluster::Structs::NestedStructList::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NestedStructList.a", "a", value.isMember("a")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NestedStructList.b", "b", value.isMember("b")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NestedStructList.c", "c", value.isMember("c")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NestedStructList.d", "d", value.isMember("d")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NestedStructList.e", "e", value.isMember("e")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NestedStructList.f", "f", value.isMember("f")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NestedStructList.g", "g", value.isMember("g")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "a");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.a, value["a"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "b");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.b, value["b"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "c");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.c, value["c"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "d");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.d, value["d"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "e");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.e, value["e"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "f");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.f, value["f"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "g");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.g, value["g"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::TestCluster::Structs::NestedStructList::Type & request)
  {
      ComplexArgumentParser::Finalize(request.a);
      ComplexArgumentParser::Finalize(request.b);
      ComplexArgumentParser::Finalize(request.c);
      ComplexArgumentParser::Finalize(request.d);
      ComplexArgumentParser::Finalize(request.e);
      ComplexArgumentParser::Finalize(request.f);
      ComplexArgumentParser::Finalize(request.g);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::NetworkCommissioning::Structs::NetworkInfo::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("NetworkInfo.networkID", "networkID", value.isMember("networkID")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("NetworkInfo.connected", "connected", value.isMember("connected")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "networkID");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.networkID, value["networkID"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "connected");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.connected, value["connected"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::NetworkCommissioning::Structs::NetworkInfo::Type & request)
  {
      ComplexArgumentParser::Finalize(request.networkID);
      ComplexArgumentParser::Finalize(request.connected);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::GeneralDiagnostics::Structs::NetworkInterfaceType::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NetworkInterfaceType.name", "name", value.isMember("name")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NetworkInterfaceType.isOperational", "isOperational",
                                                                    value.isMember("isOperational")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NetworkInterfaceType.offPremiseServicesReachableIPv4",
                                                                    "offPremiseServicesReachableIPv4",
                                                                    value.isMember("offPremiseServicesReachableIPv4")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NetworkInterfaceType.offPremiseServicesReachableIPv6",
                                                                    "offPremiseServicesReachableIPv6",
                                                                    value.isMember("offPremiseServicesReachableIPv6")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NetworkInterfaceType.hardwareAddress", "hardwareAddress",
                                                                    value.isMember("hardwareAddress")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NetworkInterfaceType.IPv4Addresses", "IPv4Addresses",
                                                                    value.isMember("IPv4Addresses")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NetworkInterfaceType.IPv6Addresses", "IPv6Addresses",
                                                                    value.isMember("IPv6Addresses")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NetworkInterfaceType.type", "type", value.isMember("type")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "name");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.name, value["name"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "isOperational");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.isOperational, value["isOperational"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "offPremiseServicesReachableIPv4");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.offPremiseServicesReachableIPv4,
                                                        value["offPremiseServicesReachableIPv4"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "offPremiseServicesReachableIPv6");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.offPremiseServicesReachableIPv6,
                                                        value["offPremiseServicesReachableIPv6"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "hardwareAddress");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.hardwareAddress, value["hardwareAddress"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "IPv4Addresses");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.IPv4Addresses, value["IPv4Addresses"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "IPv6Addresses");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.IPv6Addresses, value["IPv6Addresses"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "type");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.type, value["type"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::GeneralDiagnostics::Structs::NetworkInterfaceType::Type & request)
  {
      ComplexArgumentParser::Finalize(request.name);
      ComplexArgumentParser::Finalize(request.isOperational);
      ComplexArgumentParser::Finalize(request.offPremiseServicesReachableIPv4);
      ComplexArgumentParser::Finalize(request.offPremiseServicesReachableIPv6);
      ComplexArgumentParser::Finalize(request.hardwareAddress);
      ComplexArgumentParser::Finalize(request.IPv4Addresses);
      ComplexArgumentParser::Finalize(request.IPv6Addresses);
      ComplexArgumentParser::Finalize(request.type);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::TestCluster::Structs::NullablesAndOptionalsStruct::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NullablesAndOptionalsStruct.nullableInt", "nullableInt",
                                                                    value.isMember("nullableInt")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NullablesAndOptionalsStruct.nullableString", "nullableString",
                                                                    value.isMember("nullableString")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NullablesAndOptionalsStruct.nullableStruct", "nullableStruct",
                                                                    value.isMember("nullableStruct")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("NullablesAndOptionalsStruct.nullableList", "nullableList",
                                                                    value.isMember("nullableList")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "nullableInt");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.nullableInt, value["nullableInt"]));
  
      if (value.isMember("optionalInt"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "optionalInt");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.optionalInt, value["optionalInt"]));
      }
  
      if (value.isMember("nullableOptionalInt"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "nullableOptionalInt");
          ReturnErrorOnFailure(
              ComplexArgumentParser::Setup(labelWithMember, request.nullableOptionalInt, value["nullableOptionalInt"]));
      }
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "nullableString");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.nullableString, value["nullableString"]));
  
      if (value.isMember("optionalString"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "optionalString");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.optionalString, value["optionalString"]));
      }
  
      if (value.isMember("nullableOptionalString"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "nullableOptionalString");
          ReturnErrorOnFailure(
              ComplexArgumentParser::Setup(labelWithMember, request.nullableOptionalString, value["nullableOptionalString"]));
      }
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "nullableStruct");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.nullableStruct, value["nullableStruct"]));
  
      if (value.isMember("optionalStruct"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "optionalStruct");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.optionalStruct, value["optionalStruct"]));
      }
  
      if (value.isMember("nullableOptionalStruct"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "nullableOptionalStruct");
          ReturnErrorOnFailure(
              ComplexArgumentParser::Setup(labelWithMember, request.nullableOptionalStruct, value["nullableOptionalStruct"]));
      }
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "nullableList");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.nullableList, value["nullableList"]));
  
      if (value.isMember("optionalList"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "optionalList");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.optionalList, value["optionalList"]));
      }
  
      if (value.isMember("nullableOptionalList"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "nullableOptionalList");
          ReturnErrorOnFailure(
              ComplexArgumentParser::Setup(labelWithMember, request.nullableOptionalList, value["nullableOptionalList"]));
      }
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::TestCluster::Structs::NullablesAndOptionalsStruct::Type & request)
  {
      ComplexArgumentParser::Finalize(request.nullableInt);
      ComplexArgumentParser::Finalize(request.optionalInt);
      ComplexArgumentParser::Finalize(request.nullableOptionalInt);
      ComplexArgumentParser::Finalize(request.nullableString);
      ComplexArgumentParser::Finalize(request.optionalString);
      ComplexArgumentParser::Finalize(request.nullableOptionalString);
      ComplexArgumentParser::Finalize(request.nullableStruct);
      ComplexArgumentParser::Finalize(request.optionalStruct);
      ComplexArgumentParser::Finalize(request.nullableOptionalStruct);
      ComplexArgumentParser::Finalize(request.nullableList);
      ComplexArgumentParser::Finalize(request.optionalList);
      ComplexArgumentParser::Finalize(request.nullableOptionalList);
  }
  CHIP_ERROR
  ComplexArgumentParser::Setup(const char * label,
                               chip::app::Clusters::ThreadNetworkDiagnostics::Structs::OperationalDatasetComponents::Type & request,
                               Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist(
          "OperationalDatasetComponents.activeTimestampPresent", "activeTimestampPresent", value.isMember("activeTimestampPresent")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("OperationalDatasetComponents.pendingTimestampPresent",
                                                                    "pendingTimestampPresent",
                                                                    value.isMember("pendingTimestampPresent")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("OperationalDatasetComponents.masterKeyPresent",
                                                                    "masterKeyPresent", value.isMember("masterKeyPresent")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("OperationalDatasetComponents.networkNamePresent",
                                                                    "networkNamePresent", value.isMember("networkNamePresent")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("OperationalDatasetComponents.extendedPanIdPresent",
                                                                    "extendedPanIdPresent", value.isMember("extendedPanIdPresent")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist(
          "OperationalDatasetComponents.meshLocalPrefixPresent", "meshLocalPrefixPresent", value.isMember("meshLocalPrefixPresent")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("OperationalDatasetComponents.delayPresent", "delayPresent",
                                                                    value.isMember("delayPresent")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("OperationalDatasetComponents.panIdPresent", "panIdPresent",
                                                                    value.isMember("panIdPresent")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("OperationalDatasetComponents.channelPresent", "channelPresent",
                                                                    value.isMember("channelPresent")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("OperationalDatasetComponents.pskcPresent", "pskcPresent",
                                                                    value.isMember("pskcPresent")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist(
          "OperationalDatasetComponents.securityPolicyPresent", "securityPolicyPresent", value.isMember("securityPolicyPresent")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("OperationalDatasetComponents.channelMaskPresent",
                                                                    "channelMaskPresent", value.isMember("channelMaskPresent")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "activeTimestampPresent");
      ReturnErrorOnFailure(
          ComplexArgumentParser::Setup(labelWithMember, request.activeTimestampPresent, value["activeTimestampPresent"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "pendingTimestampPresent");
      ReturnErrorOnFailure(
          ComplexArgumentParser::Setup(labelWithMember, request.pendingTimestampPresent, value["pendingTimestampPresent"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "masterKeyPresent");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.masterKeyPresent, value["masterKeyPresent"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "networkNamePresent");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.networkNamePresent, value["networkNamePresent"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "extendedPanIdPresent");
      ReturnErrorOnFailure(
          ComplexArgumentParser::Setup(labelWithMember, request.extendedPanIdPresent, value["extendedPanIdPresent"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "meshLocalPrefixPresent");
      ReturnErrorOnFailure(
          ComplexArgumentParser::Setup(labelWithMember, request.meshLocalPrefixPresent, value["meshLocalPrefixPresent"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "delayPresent");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.delayPresent, value["delayPresent"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "panIdPresent");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.panIdPresent, value["panIdPresent"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "channelPresent");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.channelPresent, value["channelPresent"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "pskcPresent");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.pskcPresent, value["pskcPresent"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "securityPolicyPresent");
      ReturnErrorOnFailure(
          ComplexArgumentParser::Setup(labelWithMember, request.securityPolicyPresent, value["securityPolicyPresent"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "channelMaskPresent");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.channelMaskPresent, value["channelMaskPresent"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(
      chip::app::Clusters::ThreadNetworkDiagnostics::Structs::OperationalDatasetComponents::Type & request)
  {
      ComplexArgumentParser::Finalize(request.activeTimestampPresent);
      ComplexArgumentParser::Finalize(request.pendingTimestampPresent);
      ComplexArgumentParser::Finalize(request.masterKeyPresent);
      ComplexArgumentParser::Finalize(request.networkNamePresent);
      ComplexArgumentParser::Finalize(request.extendedPanIdPresent);
      ComplexArgumentParser::Finalize(request.meshLocalPrefixPresent);
      ComplexArgumentParser::Finalize(request.delayPresent);
      ComplexArgumentParser::Finalize(request.panIdPresent);
      ComplexArgumentParser::Finalize(request.channelPresent);
      ComplexArgumentParser::Finalize(request.pskcPresent);
      ComplexArgumentParser::Finalize(request.securityPolicyPresent);
      ComplexArgumentParser::Finalize(request.channelMaskPresent);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label, chip::app::Clusters::AudioOutput::Structs::OutputInfo::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("OutputInfo.index", "index", value.isMember("index")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("OutputInfo.outputType", "outputType", value.isMember("outputType")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("OutputInfo.name", "name", value.isMember("name")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "index");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.index, value["index"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "outputType");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.outputType, value["outputType"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "name");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.name, value["name"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::AudioOutput::Structs::OutputInfo::Type & request)
  {
      ComplexArgumentParser::Finalize(request.index);
      ComplexArgumentParser::Finalize(request.outputType);
      ComplexArgumentParser::Finalize(request.name);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::ContentLauncher::Structs::Parameter::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("Parameter.type", "type", value.isMember("type")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("Parameter.value", "value", value.isMember("value")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "type");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.type, value["type"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "value");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.value, value["value"]));
  
      if (value.isMember("externalIDList"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "externalIDList");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.externalIDList, value["externalIDList"]));
      }
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::ContentLauncher::Structs::Parameter::Type & request)
  {
      ComplexArgumentParser::Finalize(request.type);
      ComplexArgumentParser::Finalize(request.value);
      ComplexArgumentParser::Finalize(request.externalIDList);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::MediaPlayback::Structs::PlaybackPosition::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("PlaybackPosition.updatedAt", "updatedAt", value.isMember("updatedAt")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("PlaybackPosition.position", "position", value.isMember("position")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "updatedAt");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.updatedAt, value["updatedAt"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "position");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.position, value["position"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::MediaPlayback::Structs::PlaybackPosition::Type & request)
  {
      ComplexArgumentParser::Finalize(request.updatedAt);
      ComplexArgumentParser::Finalize(request.position);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::PowerProfile::Structs::PowerProfileRecord::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("PowerProfileRecord.powerProfileId", "powerProfileId",
                                                                    value.isMember("powerProfileId")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("PowerProfileRecord.energyPhaseId", "energyPhaseId",
                                                                    value.isMember("energyPhaseId")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist(
          "PowerProfileRecord.powerProfileRemoteControl", "powerProfileRemoteControl", value.isMember("powerProfileRemoteControl")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("PowerProfileRecord.powerProfileState", "powerProfileState",
                                                                    value.isMember("powerProfileState")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "powerProfileId");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.powerProfileId, value["powerProfileId"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "energyPhaseId");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.energyPhaseId, value["energyPhaseId"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "powerProfileRemoteControl");
      ReturnErrorOnFailure(
          ComplexArgumentParser::Setup(labelWithMember, request.powerProfileRemoteControl, value["powerProfileRemoteControl"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "powerProfileState");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.powerProfileState, value["powerProfileState"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::PowerProfile::Structs::PowerProfileRecord::Type & request)
  {
      ComplexArgumentParser::Finalize(request.powerProfileId);
      ComplexArgumentParser::Finalize(request.energyPhaseId);
      ComplexArgumentParser::Finalize(request.powerProfileRemoteControl);
      ComplexArgumentParser::Finalize(request.powerProfileState);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::OtaSoftwareUpdateRequestor::Structs::ProviderLocation::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("ProviderLocation.providerNodeID", "providerNodeID",
                                                                    value.isMember("providerNodeID")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("ProviderLocation.endpoint", "endpoint", value.isMember("endpoint")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "providerNodeID");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.providerNodeID, value["providerNodeID"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "endpoint");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.endpoint, value["endpoint"]));
  
      if (value.isMember("fabricIndex"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "fabricIndex");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.fabricIndex, value["fabricIndex"]));
      }
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::OtaSoftwareUpdateRequestor::Structs::ProviderLocation::Type & request)
  {
      ComplexArgumentParser::Finalize(request.providerNodeID);
      ComplexArgumentParser::Finalize(request.endpoint);
      ComplexArgumentParser::Finalize(request.fabricIndex);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::ThreadNetworkDiagnostics::Structs::RouteTable::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("RouteTable.extAddress", "extAddress", value.isMember("extAddress")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("RouteTable.rloc16", "rloc16", value.isMember("rloc16")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("RouteTable.routerId", "routerId", value.isMember("routerId")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("RouteTable.nextHop", "nextHop", value.isMember("nextHop")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("RouteTable.pathCost", "pathCost", value.isMember("pathCost")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("RouteTable.LQIIn", "LQIIn", value.isMember("LQIIn")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("RouteTable.LQIOut", "LQIOut", value.isMember("LQIOut")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("RouteTable.age", "age", value.isMember("age")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("RouteTable.allocated", "allocated", value.isMember("allocated")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("RouteTable.linkEstablished", "linkEstablished",
                                                                    value.isMember("linkEstablished")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "extAddress");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.extAddress, value["extAddress"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "rloc16");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.rloc16, value["rloc16"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "routerId");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.routerId, value["routerId"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "nextHop");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.nextHop, value["nextHop"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "pathCost");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.pathCost, value["pathCost"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "LQIIn");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.LQIIn, value["LQIIn"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "LQIOut");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.LQIOut, value["LQIOut"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "age");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.age, value["age"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "allocated");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.allocated, value["allocated"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "linkEstablished");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.linkEstablished, value["linkEstablished"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::ThreadNetworkDiagnostics::Structs::RouteTable::Type & request)
  {
      ComplexArgumentParser::Finalize(request.extAddress);
      ComplexArgumentParser::Finalize(request.rloc16);
      ComplexArgumentParser::Finalize(request.routerId);
      ComplexArgumentParser::Finalize(request.nextHop);
      ComplexArgumentParser::Finalize(request.pathCost);
      ComplexArgumentParser::Finalize(request.LQIIn);
      ComplexArgumentParser::Finalize(request.LQIOut);
      ComplexArgumentParser::Finalize(request.age);
      ComplexArgumentParser::Finalize(request.allocated);
      ComplexArgumentParser::Finalize(request.linkEstablished);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::Scenes::Structs::SceneExtensionFieldSet::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("SceneExtensionFieldSet.clusterId", "clusterId", value.isMember("clusterId")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("SceneExtensionFieldSet.length", "length", value.isMember("length")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("SceneExtensionFieldSet.value", "value", value.isMember("value")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "clusterId");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.clusterId, value["clusterId"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "length");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.length, value["length"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "value");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.value, value["value"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::Scenes::Structs::SceneExtensionFieldSet::Type & request)
  {
      ComplexArgumentParser::Finalize(request.clusterId);
      ComplexArgumentParser::Finalize(request.length);
      ComplexArgumentParser::Finalize(request.value);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::PowerProfile::Structs::ScheduledPhase::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("ScheduledPhase.energyPhaseId", "energyPhaseId", value.isMember("energyPhaseId")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("ScheduledPhase.scheduledTime", "scheduledTime", value.isMember("scheduledTime")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "energyPhaseId");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.energyPhaseId, value["energyPhaseId"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "scheduledTime");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.scheduledTime, value["scheduledTime"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::PowerProfile::Structs::ScheduledPhase::Type & request)
  {
      ComplexArgumentParser::Finalize(request.energyPhaseId);
      ComplexArgumentParser::Finalize(request.scheduledTime);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::ThreadNetworkDiagnostics::Structs::SecurityPolicy::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("SecurityPolicy.rotationTime", "rotationTime", value.isMember("rotationTime")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("SecurityPolicy.flags", "flags", value.isMember("flags")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "rotationTime");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.rotationTime, value["rotationTime"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "flags");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.flags, value["flags"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::ThreadNetworkDiagnostics::Structs::SecurityPolicy::Type & request)
  {
      ComplexArgumentParser::Finalize(request.rotationTime);
      ComplexArgumentParser::Finalize(request.flags);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label, chip::app::Clusters::ModeSelect::Structs::SemanticTag::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("SemanticTag.mfgCode", "mfgCode", value.isMember("mfgCode")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("SemanticTag.value", "value", value.isMember("value")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "mfgCode");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.mfgCode, value["mfgCode"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "value");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.value, value["value"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::ModeSelect::Structs::SemanticTag::Type & request)
  {
      ComplexArgumentParser::Finalize(request.mfgCode);
      ComplexArgumentParser::Finalize(request.value);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label, chip::app::Clusters::TestCluster::Structs::SimpleStruct::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("SimpleStruct.a", "a", value.isMember("a")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("SimpleStruct.b", "b", value.isMember("b")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("SimpleStruct.c", "c", value.isMember("c")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("SimpleStruct.d", "d", value.isMember("d")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("SimpleStruct.e", "e", value.isMember("e")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("SimpleStruct.f", "f", value.isMember("f")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("SimpleStruct.g", "g", value.isMember("g")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("SimpleStruct.h", "h", value.isMember("h")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "a");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.a, value["a"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "b");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.b, value["b"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "c");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.c, value["c"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "d");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.d, value["d"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "e");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.e, value["e"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "f");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.f, value["f"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "g");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.g, value["g"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "h");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.h, value["h"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::TestCluster::Structs::SimpleStruct::Type & request)
  {
      ComplexArgumentParser::Finalize(request.a);
      ComplexArgumentParser::Finalize(request.b);
      ComplexArgumentParser::Finalize(request.c);
      ComplexArgumentParser::Finalize(request.d);
      ComplexArgumentParser::Finalize(request.e);
      ComplexArgumentParser::Finalize(request.f);
      ComplexArgumentParser::Finalize(request.g);
      ComplexArgumentParser::Finalize(request.h);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::SoftwareDiagnostics::Structs::SoftwareFaultStruct::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("SoftwareFaultStruct.id", "id", value.isMember("id")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("SoftwareFaultStruct.name", "name", value.isMember("name")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("SoftwareFaultStruct.faultRecording", "faultRecording",
                                                                    value.isMember("faultRecording")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "id");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.id, value["id"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "name");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.name, value["name"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "faultRecording");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.faultRecording, value["faultRecording"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::SoftwareDiagnostics::Structs::SoftwareFaultStruct::Type & request)
  {
      ComplexArgumentParser::Finalize(request.id);
      ComplexArgumentParser::Finalize(request.name);
      ComplexArgumentParser::Finalize(request.faultRecording);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::ContentLauncher::Structs::StyleInformation::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      char labelWithMember[kMaxLabelLength];
      if (value.isMember("imageUrl"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "imageUrl");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.imageUrl, value["imageUrl"]));
      }
  
      if (value.isMember("color"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "color");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.color, value["color"]));
      }
  
      if (value.isMember("size"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "size");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.size, value["size"]));
      }
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::ContentLauncher::Structs::StyleInformation::Type & request)
  {
      ComplexArgumentParser::Finalize(request.imageUrl);
      ComplexArgumentParser::Finalize(request.color);
      ComplexArgumentParser::Finalize(request.size);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label, chip::app::Clusters::AccessControl::Structs::Target::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("Target.cluster", "cluster", value.isMember("cluster")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("Target.endpoint", "endpoint", value.isMember("endpoint")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("Target.deviceType", "deviceType", value.isMember("deviceType")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "cluster");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.cluster, value["cluster"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "endpoint");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.endpoint, value["endpoint"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "deviceType");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.deviceType, value["deviceType"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::AccessControl::Structs::Target::Type & request)
  {
      ComplexArgumentParser::Finalize(request.cluster);
      ComplexArgumentParser::Finalize(request.endpoint);
      ComplexArgumentParser::Finalize(request.deviceType);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::TargetNavigator::Structs::TargetInfo::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("TargetInfo.identifier", "identifier", value.isMember("identifier")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("TargetInfo.name", "name", value.isMember("name")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "identifier");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.identifier, value["identifier"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "name");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.name, value["name"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::TargetNavigator::Structs::TargetInfo::Type & request)
  {
      ComplexArgumentParser::Finalize(request.identifier);
      ComplexArgumentParser::Finalize(request.name);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label, chip::app::Clusters::Binding::Structs::TargetStruct::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      char labelWithMember[kMaxLabelLength];
      if (value.isMember("node"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "node");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.node, value["node"]));
      }
  
      if (value.isMember("group"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "group");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.group, value["group"]));
      }
  
      if (value.isMember("endpoint"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "endpoint");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.endpoint, value["endpoint"]));
      }
  
      if (value.isMember("cluster"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "cluster");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.cluster, value["cluster"]));
      }
  
      if (value.isMember("fabricIndex"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "fabricIndex");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.fabricIndex, value["fabricIndex"]));
      }
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::Binding::Structs::TargetStruct::Type & request)
  {
      ComplexArgumentParser::Finalize(request.node);
      ComplexArgumentParser::Finalize(request.group);
      ComplexArgumentParser::Finalize(request.endpoint);
      ComplexArgumentParser::Finalize(request.cluster);
      ComplexArgumentParser::Finalize(request.fabricIndex);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::TestCluster::Structs::TestFabricScoped::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("TestFabricScoped.fabricSensitiveInt8u", "fabricSensitiveInt8u",
                                                                    value.isMember("fabricSensitiveInt8u")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("TestFabricScoped.nullableFabricSensitiveInt8u",
                                                                    "nullableFabricSensitiveInt8u",
                                                                    value.isMember("nullableFabricSensitiveInt8u")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist(
          "TestFabricScoped.fabricSensitiveCharString", "fabricSensitiveCharString", value.isMember("fabricSensitiveCharString")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("TestFabricScoped.fabricSensitiveStruct", "fabricSensitiveStruct",
                                                                    value.isMember("fabricSensitiveStruct")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist(
          "TestFabricScoped.fabricSensitiveInt8uList", "fabricSensitiveInt8uList", value.isMember("fabricSensitiveInt8uList")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "fabricSensitiveInt8u");
      ReturnErrorOnFailure(
          ComplexArgumentParser::Setup(labelWithMember, request.fabricSensitiveInt8u, value["fabricSensitiveInt8u"]));
  
      if (value.isMember("optionalFabricSensitiveInt8u"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "optionalFabricSensitiveInt8u");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.optionalFabricSensitiveInt8u,
                                                            value["optionalFabricSensitiveInt8u"]));
      }
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "nullableFabricSensitiveInt8u");
      ReturnErrorOnFailure(
          ComplexArgumentParser::Setup(labelWithMember, request.nullableFabricSensitiveInt8u, value["nullableFabricSensitiveInt8u"]));
  
      if (value.isMember("nullableOptionalFabricSensitiveInt8u"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "nullableOptionalFabricSensitiveInt8u");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.nullableOptionalFabricSensitiveInt8u,
                                                            value["nullableOptionalFabricSensitiveInt8u"]));
      }
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "fabricSensitiveCharString");
      ReturnErrorOnFailure(
          ComplexArgumentParser::Setup(labelWithMember, request.fabricSensitiveCharString, value["fabricSensitiveCharString"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "fabricSensitiveStruct");
      ReturnErrorOnFailure(
          ComplexArgumentParser::Setup(labelWithMember, request.fabricSensitiveStruct, value["fabricSensitiveStruct"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "fabricSensitiveInt8uList");
      ReturnErrorOnFailure(
          ComplexArgumentParser::Setup(labelWithMember, request.fabricSensitiveInt8uList, value["fabricSensitiveInt8uList"]));
  
      if (value.isMember("fabricIndex"))
      {
          snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "fabricIndex");
          ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.fabricIndex, value["fabricIndex"]));
      }
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::TestCluster::Structs::TestFabricScoped::Type & request)
  {
      ComplexArgumentParser::Finalize(request.fabricSensitiveInt8u);
      ComplexArgumentParser::Finalize(request.optionalFabricSensitiveInt8u);
      ComplexArgumentParser::Finalize(request.nullableFabricSensitiveInt8u);
      ComplexArgumentParser::Finalize(request.nullableOptionalFabricSensitiveInt8u);
      ComplexArgumentParser::Finalize(request.fabricSensitiveCharString);
      ComplexArgumentParser::Finalize(request.fabricSensitiveStruct);
      ComplexArgumentParser::Finalize(request.fabricSensitiveInt8uList);
      ComplexArgumentParser::Finalize(request.fabricIndex);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::TestCluster::Structs::TestListStructOctet::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("TestListStructOctet.fabricIndex", "fabricIndex", value.isMember("fabricIndex")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("TestListStructOctet.operationalCert", "operationalCert",
                                                                    value.isMember("operationalCert")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "fabricIndex");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.fabricIndex, value["fabricIndex"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "operationalCert");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.operationalCert, value["operationalCert"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::TestCluster::Structs::TestListStructOctet::Type & request)
  {
      ComplexArgumentParser::Finalize(request.fabricIndex);
      ComplexArgumentParser::Finalize(request.operationalCert);
  }
  CHIP_ERROR
  ComplexArgumentParser::Setup(const char * label,
                               chip::app::Clusters::NetworkCommissioning::Structs::ThreadInterfaceScanResult::Type & request,
                               Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("ThreadInterfaceScanResult.panId", "panId", value.isMember("panId")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("ThreadInterfaceScanResult.extendedPanId", "extendedPanId",
                                                                    value.isMember("extendedPanId")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("ThreadInterfaceScanResult.networkName", "networkName",
                                                                    value.isMember("networkName")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("ThreadInterfaceScanResult.channel", "channel", value.isMember("channel")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("ThreadInterfaceScanResult.version", "version", value.isMember("version")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("ThreadInterfaceScanResult.extendedAddress", "extendedAddress",
                                                                    value.isMember("extendedAddress")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("ThreadInterfaceScanResult.rssi", "rssi", value.isMember("rssi")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("ThreadInterfaceScanResult.lqi", "lqi", value.isMember("lqi")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "panId");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.panId, value["panId"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "extendedPanId");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.extendedPanId, value["extendedPanId"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "networkName");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.networkName, value["networkName"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "channel");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.channel, value["channel"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "version");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.version, value["version"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "extendedAddress");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.extendedAddress, value["extendedAddress"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "rssi");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.rssi, value["rssi"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "lqi");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.lqi, value["lqi"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::NetworkCommissioning::Structs::ThreadInterfaceScanResult::Type & request)
  {
      ComplexArgumentParser::Finalize(request.panId);
      ComplexArgumentParser::Finalize(request.extendedPanId);
      ComplexArgumentParser::Finalize(request.networkName);
      ComplexArgumentParser::Finalize(request.channel);
      ComplexArgumentParser::Finalize(request.version);
      ComplexArgumentParser::Finalize(request.extendedAddress);
      ComplexArgumentParser::Finalize(request.rssi);
      ComplexArgumentParser::Finalize(request.lqi);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::SoftwareDiagnostics::Structs::ThreadMetrics::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("ThreadMetrics.id", "id", value.isMember("id")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("ThreadMetrics.name", "name", value.isMember("name")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("ThreadMetrics.stackFreeCurrent", "stackFreeCurrent",
                                                                    value.isMember("stackFreeCurrent")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("ThreadMetrics.stackFreeMinimum", "stackFreeMinimum",
                                                                    value.isMember("stackFreeMinimum")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("ThreadMetrics.stackSize", "stackSize", value.isMember("stackSize")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "id");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.id, value["id"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "name");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.name, value["name"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "stackFreeCurrent");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.stackFreeCurrent, value["stackFreeCurrent"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "stackFreeMinimum");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.stackFreeMinimum, value["stackFreeMinimum"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "stackSize");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.stackSize, value["stackSize"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::SoftwareDiagnostics::Structs::ThreadMetrics::Type & request)
  {
      ComplexArgumentParser::Finalize(request.id);
      ComplexArgumentParser::Finalize(request.name);
      ComplexArgumentParser::Finalize(request.stackFreeCurrent);
      ComplexArgumentParser::Finalize(request.stackFreeMinimum);
      ComplexArgumentParser::Finalize(request.stackSize);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::PowerProfile::Structs::TransferredPhase::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("TransferredPhase.energyPhaseId", "energyPhaseId",
                                                                    value.isMember("energyPhaseId")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("TransferredPhase.macroPhaseId", "macroPhaseId", value.isMember("macroPhaseId")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("TransferredPhase.expectedDuration", "expectedDuration",
                                                                    value.isMember("expectedDuration")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("TransferredPhase.peakPower", "peakPower", value.isMember("peakPower")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("TransferredPhase.energy", "energy", value.isMember("energy")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("TransferredPhase.maxActivationDelay", "maxActivationDelay",
                                                                    value.isMember("maxActivationDelay")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "energyPhaseId");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.energyPhaseId, value["energyPhaseId"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "macroPhaseId");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.macroPhaseId, value["macroPhaseId"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "expectedDuration");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.expectedDuration, value["expectedDuration"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "peakPower");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.peakPower, value["peakPower"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "energy");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.energy, value["energy"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "maxActivationDelay");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.maxActivationDelay, value["maxActivationDelay"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::PowerProfile::Structs::TransferredPhase::Type & request)
  {
      ComplexArgumentParser::Finalize(request.energyPhaseId);
      ComplexArgumentParser::Finalize(request.macroPhaseId);
      ComplexArgumentParser::Finalize(request.expectedDuration);
      ComplexArgumentParser::Finalize(request.peakPower);
      ComplexArgumentParser::Finalize(request.energy);
      ComplexArgumentParser::Finalize(request.maxActivationDelay);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::NetworkCommissioning::Structs::WiFiInterfaceScanResult::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("WiFiInterfaceScanResult.security", "security", value.isMember("security")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("WiFiInterfaceScanResult.ssid", "ssid", value.isMember("ssid")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("WiFiInterfaceScanResult.bssid", "bssid", value.isMember("bssid")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("WiFiInterfaceScanResult.channel", "channel", value.isMember("channel")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("WiFiInterfaceScanResult.wiFiBand", "wiFiBand", value.isMember("wiFiBand")));
      ReturnErrorOnFailure(ComplexArgumentParser::EnsureMemberExist("WiFiInterfaceScanResult.rssi", "rssi", value.isMember("rssi")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "security");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.security, value["security"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "ssid");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.ssid, value["ssid"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "bssid");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.bssid, value["bssid"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "channel");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.channel, value["channel"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "wiFiBand");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.wiFiBand, value["wiFiBand"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "rssi");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.rssi, value["rssi"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::NetworkCommissioning::Structs::WiFiInterfaceScanResult::Type & request)
  {
      ComplexArgumentParser::Finalize(request.security);
      ComplexArgumentParser::Finalize(request.ssid);
      ComplexArgumentParser::Finalize(request.bssid);
      ComplexArgumentParser::Finalize(request.channel);
      ComplexArgumentParser::Finalize(request.wiFiBand);
      ComplexArgumentParser::Finalize(request.rssi);
  }
  CHIP_ERROR ComplexArgumentParser::Setup(const char * label,
                                          chip::app::Clusters::PowerSource::Structs::WiredFaultChangeType::Type & request,
                                          Json::Value & value)
  {
      VerifyOrReturnError(value.isObject(), CHIP_ERROR_INVALID_ARGUMENT);
  
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("WiredFaultChangeType.current", "current", value.isMember("current")));
      ReturnErrorOnFailure(
          ComplexArgumentParser::EnsureMemberExist("WiredFaultChangeType.previous", "previous", value.isMember("previous")));
  
      char labelWithMember[kMaxLabelLength];
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "current");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.current, value["current"]));
  
      snprintf(labelWithMember, sizeof(labelWithMember), "%s.%s", label, "previous");
      ReturnErrorOnFailure(ComplexArgumentParser::Setup(labelWithMember, request.previous, value["previous"]));
  
      return CHIP_NO_ERROR;
  }
  
  void ComplexArgumentParser::Finalize(chip::app::Clusters::PowerSource::Structs::WiredFaultChangeType::Type & request)
  {
      ComplexArgumentParser::Finalize(request.current);
      ComplexArgumentParser::Finalize(request.previous);
  }
  