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 <app/data-model/Decode.h>
  #include <app/data-model/Encode.h>
  
  #pragma once
  
  namespace chip {
  
  struct PairWithQRCodeCommand
  {
      chip::NodeId nodeId;
      chip::CharSpan payload;
  
      CHIP_ERROR Encode(chip::TLV::TLVWriter & writer, chip::TLV::Tag tag) const
      {
          chip::TLV::TLVType outer;
          ReturnErrorOnFailure(writer.StartContainer(tag, chip::TLV::kTLVType_Structure, outer));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(0), nodeId));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(1), payload));
          ReturnErrorOnFailure(writer.EndContainer(outer));
          return CHIP_NO_ERROR;
      }
  
      CHIP_ERROR Decode(chip::TLV::TLVReader & reader)
      {
          CHIP_ERROR err = CHIP_NO_ERROR;
          chip::TLV::TLVType outer;
          VerifyOrReturnError(chip::TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
          ReturnErrorOnFailure(reader.EnterContainer(outer));
  
          while ((err = reader.Next()) == CHIP_NO_ERROR)
          {
              VerifyOrReturnError(chip::TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
              switch (chip::TLV::TagNumFromTag(reader.GetTag()))
              {
              case 0:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, nodeId));
                  break;
              case 1:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, payload));
                  break;
              default:
                  break;
              }
          }
  
          VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
          ReturnErrorOnFailure(reader.ExitContainer(outer));
  
          return CHIP_NO_ERROR;
      }
  };
  
  struct PairWithManualCodeCommand
  {
      chip::NodeId nodeId;
      chip::CharSpan payload;
  
      CHIP_ERROR Encode(chip::TLV::TLVWriter & writer, chip::TLV::Tag tag) const
      {
          chip::TLV::TLVType outer;
          ReturnErrorOnFailure(writer.StartContainer(tag, chip::TLV::kTLVType_Structure, outer));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(0), nodeId));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(1), payload));
          ReturnErrorOnFailure(writer.EndContainer(outer));
          return CHIP_NO_ERROR;
      }
  
      CHIP_ERROR Decode(chip::TLV::TLVReader & reader)
      {
          CHIP_ERROR err = CHIP_NO_ERROR;
          chip::TLV::TLVType outer;
          VerifyOrReturnError(chip::TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
          ReturnErrorOnFailure(reader.EnterContainer(outer));
  
          while ((err = reader.Next()) == CHIP_NO_ERROR)
          {
              VerifyOrReturnError(chip::TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
              switch (chip::TLV::TagNumFromTag(reader.GetTag()))
              {
              case 0:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, nodeId));
                  break;
              case 1:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, payload));
                  break;
              default:
                  break;
              }
          }
  
          VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
          ReturnErrorOnFailure(reader.ExitContainer(outer));
  
          return CHIP_NO_ERROR;
      }
  };
  
  struct UnpairCommand
  {
      chip::NodeId nodeId;
  
      CHIP_ERROR Encode(chip::TLV::TLVWriter & writer, chip::TLV::Tag tag) const
      {
          chip::TLV::TLVType outer;
          ReturnErrorOnFailure(writer.StartContainer(tag, chip::TLV::kTLVType_Structure, outer));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(0), nodeId));
          ReturnErrorOnFailure(writer.EndContainer(outer));
          return CHIP_NO_ERROR;
      }
  
      CHIP_ERROR Decode(chip::TLV::TLVReader & reader)
      {
          CHIP_ERROR err = CHIP_NO_ERROR;
          chip::TLV::TLVType outer;
          VerifyOrReturnError(chip::TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
          ReturnErrorOnFailure(reader.EnterContainer(outer));
  
          while ((err = reader.Next()) == CHIP_NO_ERROR)
          {
              VerifyOrReturnError(chip::TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
              switch (chip::TLV::TagNumFromTag(reader.GetTag()))
              {
              case 0:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, nodeId));
                  break;
              default:
                  break;
              }
          }
  
          VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
          ReturnErrorOnFailure(reader.ExitContainer(outer));
  
          return CHIP_NO_ERROR;
      }
  };
  
  struct WaitForMsCommand
  {
      uint32_t ms;
  
      CHIP_ERROR Encode(chip::TLV::TLVWriter & writer, chip::TLV::Tag tag) const
      {
          chip::TLV::TLVType outer;
          ReturnErrorOnFailure(writer.StartContainer(tag, chip::TLV::kTLVType_Structure, outer));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(0), ms));
          ReturnErrorOnFailure(writer.EndContainer(outer));
          return CHIP_NO_ERROR;
      }
  
      CHIP_ERROR Decode(chip::TLV::TLVReader & reader)
      {
          CHIP_ERROR err = CHIP_NO_ERROR;
          chip::TLV::TLVType outer;
          VerifyOrReturnError(chip::TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
          ReturnErrorOnFailure(reader.EnterContainer(outer));
  
          while ((err = reader.Next()) == CHIP_NO_ERROR)
          {
              VerifyOrReturnError(chip::TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
              switch (chip::TLV::TagNumFromTag(reader.GetTag()))
              {
              case 0:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, ms));
                  break;
              default:
                  break;
              }
          }
  
          VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
          ReturnErrorOnFailure(reader.ExitContainer(outer));
  
          return CHIP_NO_ERROR;
      }
  };
  
  struct WaitForCommissioningCommand
  {
  
      CHIP_ERROR Encode(chip::TLV::TLVWriter & writer, chip::TLV::Tag tag) const
      {
          chip::TLV::TLVType outer;
          ReturnErrorOnFailure(writer.StartContainer(tag, chip::TLV::kTLVType_Structure, outer));
          ReturnErrorOnFailure(writer.EndContainer(outer));
          return CHIP_NO_ERROR;
      }
  
      CHIP_ERROR Decode(chip::TLV::TLVReader & reader)
      {
          CHIP_ERROR err = CHIP_NO_ERROR;
          chip::TLV::TLVType outer;
          VerifyOrReturnError(chip::TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
          ReturnErrorOnFailure(reader.EnterContainer(outer));
  
          while ((err = reader.Next()) == CHIP_NO_ERROR)
          {
              VerifyOrReturnError(chip::TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
              switch (chip::TLV::TagNumFromTag(reader.GetTag()))
              {
              default:
                  break;
              }
          }
  
          VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
          ReturnErrorOnFailure(reader.ExitContainer(outer));
  
          return CHIP_NO_ERROR;
      }
  };
  
  struct WaitForCommissioneeCommand
  {
      chip::NodeId nodeId;
  
      CHIP_ERROR Encode(chip::TLV::TLVWriter & writer, chip::TLV::Tag tag) const
      {
          chip::TLV::TLVType outer;
          ReturnErrorOnFailure(writer.StartContainer(tag, chip::TLV::kTLVType_Structure, outer));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(0), nodeId));
          ReturnErrorOnFailure(writer.EndContainer(outer));
          return CHIP_NO_ERROR;
      }
  
      CHIP_ERROR Decode(chip::TLV::TLVReader & reader)
      {
          CHIP_ERROR err = CHIP_NO_ERROR;
          chip::TLV::TLVType outer;
          VerifyOrReturnError(chip::TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
          ReturnErrorOnFailure(reader.EnterContainer(outer));
  
          while ((err = reader.Next()) == CHIP_NO_ERROR)
          {
              VerifyOrReturnError(chip::TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
              switch (chip::TLV::TagNumFromTag(reader.GetTag()))
              {
              case 0:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, nodeId));
                  break;
              default:
                  break;
              }
          }
  
          VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
          ReturnErrorOnFailure(reader.ExitContainer(outer));
  
          return CHIP_NO_ERROR;
      }
  };
  
  struct WaitForMessageCommand
  {
      Optional<chip::CharSpan> registerKey;
      chip::CharSpan message;
  
      CHIP_ERROR Encode(chip::TLV::TLVWriter & writer, chip::TLV::Tag tag) const
      {
          chip::TLV::TLVType outer;
          ReturnErrorOnFailure(writer.StartContainer(tag, chip::TLV::kTLVType_Structure, outer));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(0), registerKey));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(1), message));
          ReturnErrorOnFailure(writer.EndContainer(outer));
          return CHIP_NO_ERROR;
      }
  
      CHIP_ERROR Decode(chip::TLV::TLVReader & reader)
      {
          CHIP_ERROR err = CHIP_NO_ERROR;
          chip::TLV::TLVType outer;
          VerifyOrReturnError(chip::TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
          ReturnErrorOnFailure(reader.EnterContainer(outer));
  
          while ((err = reader.Next()) == CHIP_NO_ERROR)
          {
              VerifyOrReturnError(chip::TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
              switch (chip::TLV::TagNumFromTag(reader.GetTag()))
              {
              case 0:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, registerKey));
                  break;
              case 1:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, message));
                  break;
              default:
                  break;
              }
          }
  
          VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
          ReturnErrorOnFailure(reader.ExitContainer(outer));
  
          return CHIP_NO_ERROR;
      }
  };
  
  struct FindCommissionableCommand
  {
  
      CHIP_ERROR Encode(chip::TLV::TLVWriter & writer, chip::TLV::Tag tag) const
      {
          chip::TLV::TLVType outer;
          ReturnErrorOnFailure(writer.StartContainer(tag, chip::TLV::kTLVType_Structure, outer));
          ReturnErrorOnFailure(writer.EndContainer(outer));
          return CHIP_NO_ERROR;
      }
  
      CHIP_ERROR Decode(chip::TLV::TLVReader & reader)
      {
          CHIP_ERROR err = CHIP_NO_ERROR;
          chip::TLV::TLVType outer;
          VerifyOrReturnError(chip::TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
          ReturnErrorOnFailure(reader.EnterContainer(outer));
  
          while ((err = reader.Next()) == CHIP_NO_ERROR)
          {
              VerifyOrReturnError(chip::TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
              switch (chip::TLV::TagNumFromTag(reader.GetTag()))
              {
              default:
                  break;
              }
          }
  
          VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
          ReturnErrorOnFailure(reader.ExitContainer(outer));
  
          return CHIP_NO_ERROR;
      }
  };
  
  struct FindCommissionableByShortDiscriminatorCommand
  {
      uint64_t value;
  
      CHIP_ERROR Encode(chip::TLV::TLVWriter & writer, chip::TLV::Tag tag) const
      {
          chip::TLV::TLVType outer;
          ReturnErrorOnFailure(writer.StartContainer(tag, chip::TLV::kTLVType_Structure, outer));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(0), value));
          ReturnErrorOnFailure(writer.EndContainer(outer));
          return CHIP_NO_ERROR;
      }
  
      CHIP_ERROR Decode(chip::TLV::TLVReader & reader)
      {
          CHIP_ERROR err = CHIP_NO_ERROR;
          chip::TLV::TLVType outer;
          VerifyOrReturnError(chip::TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
          ReturnErrorOnFailure(reader.EnterContainer(outer));
  
          while ((err = reader.Next()) == CHIP_NO_ERROR)
          {
              VerifyOrReturnError(chip::TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
              switch (chip::TLV::TagNumFromTag(reader.GetTag()))
              {
              case 0:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, value));
                  break;
              default:
                  break;
              }
          }
  
          VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
          ReturnErrorOnFailure(reader.ExitContainer(outer));
  
          return CHIP_NO_ERROR;
      }
  };
  
  struct FindCommissionableByLongDiscriminatorCommand
  {
      uint64_t value;
  
      CHIP_ERROR Encode(chip::TLV::TLVWriter & writer, chip::TLV::Tag tag) const
      {
          chip::TLV::TLVType outer;
          ReturnErrorOnFailure(writer.StartContainer(tag, chip::TLV::kTLVType_Structure, outer));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(0), value));
          ReturnErrorOnFailure(writer.EndContainer(outer));
          return CHIP_NO_ERROR;
      }
  
      CHIP_ERROR Decode(chip::TLV::TLVReader & reader)
      {
          CHIP_ERROR err = CHIP_NO_ERROR;
          chip::TLV::TLVType outer;
          VerifyOrReturnError(chip::TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
          ReturnErrorOnFailure(reader.EnterContainer(outer));
  
          while ((err = reader.Next()) == CHIP_NO_ERROR)
          {
              VerifyOrReturnError(chip::TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
              switch (chip::TLV::TagNumFromTag(reader.GetTag()))
              {
              case 0:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, value));
                  break;
              default:
                  break;
              }
          }
  
          VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
          ReturnErrorOnFailure(reader.ExitContainer(outer));
  
          return CHIP_NO_ERROR;
      }
  };
  
  struct FindCommissionableByCommissioningModeCommand
  {
  
      CHIP_ERROR Encode(chip::TLV::TLVWriter & writer, chip::TLV::Tag tag) const
      {
          chip::TLV::TLVType outer;
          ReturnErrorOnFailure(writer.StartContainer(tag, chip::TLV::kTLVType_Structure, outer));
          ReturnErrorOnFailure(writer.EndContainer(outer));
          return CHIP_NO_ERROR;
      }
  
      CHIP_ERROR Decode(chip::TLV::TLVReader & reader)
      {
          CHIP_ERROR err = CHIP_NO_ERROR;
          chip::TLV::TLVType outer;
          VerifyOrReturnError(chip::TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
          ReturnErrorOnFailure(reader.EnterContainer(outer));
  
          while ((err = reader.Next()) == CHIP_NO_ERROR)
          {
              VerifyOrReturnError(chip::TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
              switch (chip::TLV::TagNumFromTag(reader.GetTag()))
              {
              default:
                  break;
              }
          }
  
          VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
          ReturnErrorOnFailure(reader.ExitContainer(outer));
  
          return CHIP_NO_ERROR;
      }
  };
  
  struct FindCommissionableByVendorIdCommand
  {
      uint64_t value;
  
      CHIP_ERROR Encode(chip::TLV::TLVWriter & writer, chip::TLV::Tag tag) const
      {
          chip::TLV::TLVType outer;
          ReturnErrorOnFailure(writer.StartContainer(tag, chip::TLV::kTLVType_Structure, outer));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(0), value));
          ReturnErrorOnFailure(writer.EndContainer(outer));
          return CHIP_NO_ERROR;
      }
  
      CHIP_ERROR Decode(chip::TLV::TLVReader & reader)
      {
          CHIP_ERROR err = CHIP_NO_ERROR;
          chip::TLV::TLVType outer;
          VerifyOrReturnError(chip::TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
          ReturnErrorOnFailure(reader.EnterContainer(outer));
  
          while ((err = reader.Next()) == CHIP_NO_ERROR)
          {
              VerifyOrReturnError(chip::TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
              switch (chip::TLV::TagNumFromTag(reader.GetTag()))
              {
              case 0:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, value));
                  break;
              default:
                  break;
              }
          }
  
          VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
          ReturnErrorOnFailure(reader.ExitContainer(outer));
  
          return CHIP_NO_ERROR;
      }
  };
  
  struct FindCommissionableByDeviceTypeCommand
  {
      uint64_t value;
  
      CHIP_ERROR Encode(chip::TLV::TLVWriter & writer, chip::TLV::Tag tag) const
      {
          chip::TLV::TLVType outer;
          ReturnErrorOnFailure(writer.StartContainer(tag, chip::TLV::kTLVType_Structure, outer));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(0), value));
          ReturnErrorOnFailure(writer.EndContainer(outer));
          return CHIP_NO_ERROR;
      }
  
      CHIP_ERROR Decode(chip::TLV::TLVReader & reader)
      {
          CHIP_ERROR err = CHIP_NO_ERROR;
          chip::TLV::TLVType outer;
          VerifyOrReturnError(chip::TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
          ReturnErrorOnFailure(reader.EnterContainer(outer));
  
          while ((err = reader.Next()) == CHIP_NO_ERROR)
          {
              VerifyOrReturnError(chip::TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
              switch (chip::TLV::TagNumFromTag(reader.GetTag()))
              {
              case 0:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, value));
                  break;
              default:
                  break;
              }
          }
  
          VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
          ReturnErrorOnFailure(reader.ExitContainer(outer));
  
          return CHIP_NO_ERROR;
      }
  };
  
  struct FindCommissionableByNameCommand
  {
      chip::CharSpan value;
  
      CHIP_ERROR Encode(chip::TLV::TLVWriter & writer, chip::TLV::Tag tag) const
      {
          chip::TLV::TLVType outer;
          ReturnErrorOnFailure(writer.StartContainer(tag, chip::TLV::kTLVType_Structure, outer));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(0), value));
          ReturnErrorOnFailure(writer.EndContainer(outer));
          return CHIP_NO_ERROR;
      }
  
      CHIP_ERROR Decode(chip::TLV::TLVReader & reader)
      {
          CHIP_ERROR err = CHIP_NO_ERROR;
          chip::TLV::TLVType outer;
          VerifyOrReturnError(chip::TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
          ReturnErrorOnFailure(reader.EnterContainer(outer));
  
          while ((err = reader.Next()) == CHIP_NO_ERROR)
          {
              VerifyOrReturnError(chip::TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
              switch (chip::TLV::TagNumFromTag(reader.GetTag()))
              {
              case 0:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, value));
                  break;
              default:
                  break;
              }
          }
  
          VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
          ReturnErrorOnFailure(reader.ExitContainer(outer));
  
          return CHIP_NO_ERROR;
      }
  };
  
  struct FindCommissionerCommand
  {
  
      CHIP_ERROR Encode(chip::TLV::TLVWriter & writer, chip::TLV::Tag tag) const
      {
          chip::TLV::TLVType outer;
          ReturnErrorOnFailure(writer.StartContainer(tag, chip::TLV::kTLVType_Structure, outer));
          ReturnErrorOnFailure(writer.EndContainer(outer));
          return CHIP_NO_ERROR;
      }
  
      CHIP_ERROR Decode(chip::TLV::TLVReader & reader)
      {
          CHIP_ERROR err = CHIP_NO_ERROR;
          chip::TLV::TLVType outer;
          VerifyOrReturnError(chip::TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
          ReturnErrorOnFailure(reader.EnterContainer(outer));
  
          while ((err = reader.Next()) == CHIP_NO_ERROR)
          {
              VerifyOrReturnError(chip::TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
              switch (chip::TLV::TagNumFromTag(reader.GetTag()))
              {
              default:
                  break;
              }
          }
  
          VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
          ReturnErrorOnFailure(reader.ExitContainer(outer));
  
          return CHIP_NO_ERROR;
      }
  };
  
  struct FindCommissionerByVendorIdCommand
  {
      uint64_t value;
  
      CHIP_ERROR Encode(chip::TLV::TLVWriter & writer, chip::TLV::Tag tag) const
      {
          chip::TLV::TLVType outer;
          ReturnErrorOnFailure(writer.StartContainer(tag, chip::TLV::kTLVType_Structure, outer));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(0), value));
          ReturnErrorOnFailure(writer.EndContainer(outer));
          return CHIP_NO_ERROR;
      }
  
      CHIP_ERROR Decode(chip::TLV::TLVReader & reader)
      {
          CHIP_ERROR err = CHIP_NO_ERROR;
          chip::TLV::TLVType outer;
          VerifyOrReturnError(chip::TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
          ReturnErrorOnFailure(reader.EnterContainer(outer));
  
          while ((err = reader.Next()) == CHIP_NO_ERROR)
          {
              VerifyOrReturnError(chip::TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
              switch (chip::TLV::TagNumFromTag(reader.GetTag()))
              {
              case 0:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, value));
                  break;
              default:
                  break;
              }
          }
  
          VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
          ReturnErrorOnFailure(reader.ExitContainer(outer));
  
          return CHIP_NO_ERROR;
      }
  };
  
  struct FindCommissionerByDeviceTypeCommand
  {
      uint64_t value;
  
      CHIP_ERROR Encode(chip::TLV::TLVWriter & writer, chip::TLV::Tag tag) const
      {
          chip::TLV::TLVType outer;
          ReturnErrorOnFailure(writer.StartContainer(tag, chip::TLV::kTLVType_Structure, outer));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(0), value));
          ReturnErrorOnFailure(writer.EndContainer(outer));
          return CHIP_NO_ERROR;
      }
  
      CHIP_ERROR Decode(chip::TLV::TLVReader & reader)
      {
          CHIP_ERROR err = CHIP_NO_ERROR;
          chip::TLV::TLVType outer;
          VerifyOrReturnError(chip::TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
          ReturnErrorOnFailure(reader.EnterContainer(outer));
  
          while ((err = reader.Next()) == CHIP_NO_ERROR)
          {
              VerifyOrReturnError(chip::TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
              switch (chip::TLV::TagNumFromTag(reader.GetTag()))
              {
              case 0:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, value));
                  break;
              default:
                  break;
              }
          }
  
          VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
          ReturnErrorOnFailure(reader.ExitContainer(outer));
  
          return CHIP_NO_ERROR;
      }
  };
  
  struct DiscoveryCommandResponse
  {
      chip::CharSpan hostName;
      chip::CharSpan instanceName;
      uint16_t longDiscriminator;
      uint8_t shortDiscriminator;
      uint16_t vendorId;
      uint16_t productId;
      uint8_t commissioningMode;
      uint16_t deviceType;
      chip::CharSpan deviceName;
      chip::ByteSpan rotatingId;
      uint64_t rotatingIdLen;
      uint16_t pairingHint;
      chip::CharSpan pairingInstruction;
      bool supportsTcp;
      uint8_t numIPs;
      uint16_t port;
      Optional<uint32_t> mrpRetryIntervalIdle;
      Optional<uint32_t> mrpRetryIntervalActive;
  
      CHIP_ERROR Encode(chip::TLV::TLVWriter & writer, chip::TLV::Tag tag) const
      {
          chip::TLV::TLVType outer;
          ReturnErrorOnFailure(writer.StartContainer(tag, chip::TLV::kTLVType_Structure, outer));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(0), hostName));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(1), instanceName));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(2), longDiscriminator));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(3), shortDiscriminator));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(4), vendorId));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(5), productId));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(6), commissioningMode));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(7), deviceType));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(8), deviceName));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(9), rotatingId));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(10), rotatingIdLen));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(11), pairingHint));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(12), pairingInstruction));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(13), supportsTcp));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(14), numIPs));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(15), port));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(16), mrpRetryIntervalIdle));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(17), mrpRetryIntervalActive));
          ReturnErrorOnFailure(writer.EndContainer(outer));
          return CHIP_NO_ERROR;
      }
  
      CHIP_ERROR Decode(chip::TLV::TLVReader & reader)
      {
          CHIP_ERROR err = CHIP_NO_ERROR;
          chip::TLV::TLVType outer;
          VerifyOrReturnError(chip::TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
          ReturnErrorOnFailure(reader.EnterContainer(outer));
  
          while ((err = reader.Next()) == CHIP_NO_ERROR)
          {
              VerifyOrReturnError(chip::TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
              switch (chip::TLV::TagNumFromTag(reader.GetTag()))
              {
              case 0:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, hostName));
                  break;
              case 1:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, instanceName));
                  break;
              case 2:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, longDiscriminator));
                  break;
              case 3:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, shortDiscriminator));
                  break;
              case 4:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, vendorId));
                  break;
              case 5:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, productId));
                  break;
              case 6:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, commissioningMode));
                  break;
              case 7:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, deviceType));
                  break;
              case 8:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, deviceName));
                  break;
              case 9:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, rotatingId));
                  break;
              case 10:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, rotatingIdLen));
                  break;
              case 11:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, pairingHint));
                  break;
              case 12:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, pairingInstruction));
                  break;
              case 13:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, supportsTcp));
                  break;
              case 14:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, numIPs));
                  break;
              case 15:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, port));
                  break;
              case 16:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, mrpRetryIntervalIdle));
                  break;
              case 17:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, mrpRetryIntervalActive));
                  break;
              default:
                  break;
              }
          }
  
          VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
          ReturnErrorOnFailure(reader.ExitContainer(outer));
  
          return CHIP_NO_ERROR;
      }
  };
  
  struct LogCommand
  {
      chip::CharSpan message;
  
      CHIP_ERROR Encode(chip::TLV::TLVWriter & writer, chip::TLV::Tag tag) const
      {
          chip::TLV::TLVType outer;
          ReturnErrorOnFailure(writer.StartContainer(tag, chip::TLV::kTLVType_Structure, outer));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(0), message));
          ReturnErrorOnFailure(writer.EndContainer(outer));
          return CHIP_NO_ERROR;
      }
  
      CHIP_ERROR Decode(chip::TLV::TLVReader & reader)
      {
          CHIP_ERROR err = CHIP_NO_ERROR;
          chip::TLV::TLVType outer;
          VerifyOrReturnError(chip::TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
          ReturnErrorOnFailure(reader.EnterContainer(outer));
  
          while ((err = reader.Next()) == CHIP_NO_ERROR)
          {
              VerifyOrReturnError(chip::TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
              switch (chip::TLV::TagNumFromTag(reader.GetTag()))
              {
              case 0:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, message));
                  break;
              default:
                  break;
              }
          }
  
          VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
          ReturnErrorOnFailure(reader.ExitContainer(outer));
  
          return CHIP_NO_ERROR;
      }
  };
  
  struct UserPromptCommand
  {
      chip::CharSpan message;
      Optional<chip::CharSpan> expectedValue;
  
      CHIP_ERROR Encode(chip::TLV::TLVWriter & writer, chip::TLV::Tag tag) const
      {
          chip::TLV::TLVType outer;
          ReturnErrorOnFailure(writer.StartContainer(tag, chip::TLV::kTLVType_Structure, outer));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(0), message));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(1), expectedValue));
          ReturnErrorOnFailure(writer.EndContainer(outer));
          return CHIP_NO_ERROR;
      }
  
      CHIP_ERROR Decode(chip::TLV::TLVReader & reader)
      {
          CHIP_ERROR err = CHIP_NO_ERROR;
          chip::TLV::TLVType outer;
          VerifyOrReturnError(chip::TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
          ReturnErrorOnFailure(reader.EnterContainer(outer));
  
          while ((err = reader.Next()) == CHIP_NO_ERROR)
          {
              VerifyOrReturnError(chip::TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
              switch (chip::TLV::TagNumFromTag(reader.GetTag()))
              {
              case 0:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, message));
                  break;
              case 1:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, expectedValue));
                  break;
              default:
                  break;
              }
          }
  
          VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
          ReturnErrorOnFailure(reader.ExitContainer(outer));
  
          return CHIP_NO_ERROR;
      }
  };
  
  struct StartCommand
  {
      Optional<chip::CharSpan> registerKey;
      Optional<uint16_t> discriminator;
      Optional<uint16_t> port;
      Optional<chip::CharSpan> kvs;
      Optional<uint16_t> minCommissioningTimeout;
      Optional<chip::CharSpan> filepath;
      Optional<chip::CharSpan> otaDownloadPath;
  
      CHIP_ERROR Encode(chip::TLV::TLVWriter & writer, chip::TLV::Tag tag) const
      {
          chip::TLV::TLVType outer;
          ReturnErrorOnFailure(writer.StartContainer(tag, chip::TLV::kTLVType_Structure, outer));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(0), registerKey));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(1), discriminator));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(2), port));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(3), kvs));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(4), minCommissioningTimeout));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(5), filepath));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(6), otaDownloadPath));
          ReturnErrorOnFailure(writer.EndContainer(outer));
          return CHIP_NO_ERROR;
      }
  
      CHIP_ERROR Decode(chip::TLV::TLVReader & reader)
      {
          CHIP_ERROR err = CHIP_NO_ERROR;
          chip::TLV::TLVType outer;
          VerifyOrReturnError(chip::TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
          ReturnErrorOnFailure(reader.EnterContainer(outer));
  
          while ((err = reader.Next()) == CHIP_NO_ERROR)
          {
              VerifyOrReturnError(chip::TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
              switch (chip::TLV::TagNumFromTag(reader.GetTag()))
              {
              case 0:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, registerKey));
                  break;
              case 1:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, discriminator));
                  break;
              case 2:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, port));
                  break;
              case 3:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, kvs));
                  break;
              case 4:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, minCommissioningTimeout));
                  break;
              case 5:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, filepath));
                  break;
              case 6:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, otaDownloadPath));
                  break;
              default:
                  break;
              }
          }
  
          VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
          ReturnErrorOnFailure(reader.ExitContainer(outer));
  
          return CHIP_NO_ERROR;
      }
  };
  
  struct StopCommand
  {
      Optional<chip::CharSpan> registerKey;
  
      CHIP_ERROR Encode(chip::TLV::TLVWriter & writer, chip::TLV::Tag tag) const
      {
          chip::TLV::TLVType outer;
          ReturnErrorOnFailure(writer.StartContainer(tag, chip::TLV::kTLVType_Structure, outer));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(0), registerKey));
          ReturnErrorOnFailure(writer.EndContainer(outer));
          return CHIP_NO_ERROR;
      }
  
      CHIP_ERROR Decode(chip::TLV::TLVReader & reader)
      {
          CHIP_ERROR err = CHIP_NO_ERROR;
          chip::TLV::TLVType outer;
          VerifyOrReturnError(chip::TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
          ReturnErrorOnFailure(reader.EnterContainer(outer));
  
          while ((err = reader.Next()) == CHIP_NO_ERROR)
          {
              VerifyOrReturnError(chip::TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
              switch (chip::TLV::TagNumFromTag(reader.GetTag()))
              {
              case 0:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, registerKey));
                  break;
              default:
                  break;
              }
          }
  
          VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
          ReturnErrorOnFailure(reader.ExitContainer(outer));
  
          return CHIP_NO_ERROR;
      }
  };
  
  struct RebootCommand
  {
      Optional<chip::CharSpan> registerKey;
  
      CHIP_ERROR Encode(chip::TLV::TLVWriter & writer, chip::TLV::Tag tag) const
      {
          chip::TLV::TLVType outer;
          ReturnErrorOnFailure(writer.StartContainer(tag, chip::TLV::kTLVType_Structure, outer));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(0), registerKey));
          ReturnErrorOnFailure(writer.EndContainer(outer));
          return CHIP_NO_ERROR;
      }
  
      CHIP_ERROR Decode(chip::TLV::TLVReader & reader)
      {
          CHIP_ERROR err = CHIP_NO_ERROR;
          chip::TLV::TLVType outer;
          VerifyOrReturnError(chip::TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
          ReturnErrorOnFailure(reader.EnterContainer(outer));
  
          while ((err = reader.Next()) == CHIP_NO_ERROR)
          {
              VerifyOrReturnError(chip::TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
              switch (chip::TLV::TagNumFromTag(reader.GetTag()))
              {
              case 0:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, registerKey));
                  break;
              default:
                  break;
              }
          }
  
          VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
          ReturnErrorOnFailure(reader.ExitContainer(outer));
  
          return CHIP_NO_ERROR;
      }
  };
  
  struct FactoryResetCommand
  {
      Optional<chip::CharSpan> registerKey;
  
      CHIP_ERROR Encode(chip::TLV::TLVWriter & writer, chip::TLV::Tag tag) const
      {
          chip::TLV::TLVType outer;
          ReturnErrorOnFailure(writer.StartContainer(tag, chip::TLV::kTLVType_Structure, outer));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(0), registerKey));
          ReturnErrorOnFailure(writer.EndContainer(outer));
          return CHIP_NO_ERROR;
      }
  
      CHIP_ERROR Decode(chip::TLV::TLVReader & reader)
      {
          CHIP_ERROR err = CHIP_NO_ERROR;
          chip::TLV::TLVType outer;
          VerifyOrReturnError(chip::TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
          ReturnErrorOnFailure(reader.EnterContainer(outer));
  
          while ((err = reader.Next()) == CHIP_NO_ERROR)
          {
              VerifyOrReturnError(chip::TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
              switch (chip::TLV::TagNumFromTag(reader.GetTag()))
              {
              case 0:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, registerKey));
                  break;
              default:
                  break;
              }
          }
  
          VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
          ReturnErrorOnFailure(reader.ExitContainer(outer));
  
          return CHIP_NO_ERROR;
      }
  };
  
  struct CreateOtaImageCommand
  {
      chip::CharSpan otaImageFilePath;
      chip::CharSpan rawImageFilePath;
      chip::CharSpan rawImageContent;
  
      CHIP_ERROR Encode(chip::TLV::TLVWriter & writer, chip::TLV::Tag tag) const
      {
          chip::TLV::TLVType outer;
          ReturnErrorOnFailure(writer.StartContainer(tag, chip::TLV::kTLVType_Structure, outer));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(0), otaImageFilePath));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(1), rawImageFilePath));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(2), rawImageContent));
          ReturnErrorOnFailure(writer.EndContainer(outer));
          return CHIP_NO_ERROR;
      }
  
      CHIP_ERROR Decode(chip::TLV::TLVReader & reader)
      {
          CHIP_ERROR err = CHIP_NO_ERROR;
          chip::TLV::TLVType outer;
          VerifyOrReturnError(chip::TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
          ReturnErrorOnFailure(reader.EnterContainer(outer));
  
          while ((err = reader.Next()) == CHIP_NO_ERROR)
          {
              VerifyOrReturnError(chip::TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
              switch (chip::TLV::TagNumFromTag(reader.GetTag()))
              {
              case 0:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, otaImageFilePath));
                  break;
              case 1:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, rawImageFilePath));
                  break;
              case 2:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, rawImageContent));
                  break;
              default:
                  break;
              }
          }
  
          VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
          ReturnErrorOnFailure(reader.ExitContainer(outer));
  
          return CHIP_NO_ERROR;
      }
  };
  
  struct CompareFilesCommand
  {
      chip::CharSpan file1;
      chip::CharSpan file2;
  
      CHIP_ERROR Encode(chip::TLV::TLVWriter & writer, chip::TLV::Tag tag) const
      {
          chip::TLV::TLVType outer;
          ReturnErrorOnFailure(writer.StartContainer(tag, chip::TLV::kTLVType_Structure, outer));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(0), file1));
          ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::ContextTag(1), file2));
          ReturnErrorOnFailure(writer.EndContainer(outer));
          return CHIP_NO_ERROR;
      }
  
      CHIP_ERROR Decode(chip::TLV::TLVReader & reader)
      {
          CHIP_ERROR err = CHIP_NO_ERROR;
          chip::TLV::TLVType outer;
          VerifyOrReturnError(chip::TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
          ReturnErrorOnFailure(reader.EnterContainer(outer));
  
          while ((err = reader.Next()) == CHIP_NO_ERROR)
          {
              VerifyOrReturnError(chip::TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
              switch (chip::TLV::TagNumFromTag(reader.GetTag()))
              {
              case 0:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, file1));
                  break;
              case 1:
                  ReturnErrorOnFailure(chip::app::DataModel::Decode(reader, file2));
                  break;
              default:
                  break;
              }
          }
  
          VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
          ReturnErrorOnFailure(reader.ExitContainer(outer));
  
          return CHIP_NO_ERROR;
      }
  };
  
  namespace app {
  namespace Clusters {
  
  namespace CommissionerCommands {
  namespace Commands {
  namespace PairWithQRCode {
  using Type = struct PairWithQRCodeCommand;
  }
  namespace PairWithManualCode {
  using Type = struct PairWithManualCodeCommand;
  }
  namespace Unpair {
  using Type = struct UnpairCommand;
  }
  } // namespace Commands
  } // namespace CommissionerCommands
  
  namespace DelayCommands {
  namespace Commands {
  namespace WaitForMs {
  using Type = struct WaitForMsCommand;
  }
  namespace WaitForCommissioning {
  using Type = struct WaitForCommissioningCommand;
  }
  namespace WaitForCommissionee {
  using Type = struct WaitForCommissioneeCommand;
  }
  namespace WaitForMessage {
  using Type = struct WaitForMessageCommand;
  }
  } // namespace Commands
  } // namespace DelayCommands
  
  namespace DiscoveryCommands {
  namespace Commands {
  namespace FindCommissionable {
  using Type = struct FindCommissionableCommand;
  }
  namespace FindCommissionableByShortDiscriminator {
  using Type = struct FindCommissionableByShortDiscriminatorCommand;
  }
  namespace FindCommissionableByLongDiscriminator {
  using Type = struct FindCommissionableByLongDiscriminatorCommand;
  }
  namespace FindCommissionableByCommissioningMode {
  using Type = struct FindCommissionableByCommissioningModeCommand;
  }
  namespace FindCommissionableByVendorId {
  using Type = struct FindCommissionableByVendorIdCommand;
  }
  namespace FindCommissionableByDeviceType {
  using Type = struct FindCommissionableByDeviceTypeCommand;
  }
  namespace FindCommissionableByName {
  using Type = struct FindCommissionableByNameCommand;
  }
  namespace FindCommissioner {
  using Type = struct FindCommissionerCommand;
  }
  namespace FindCommissionerByVendorId {
  using Type = struct FindCommissionerByVendorIdCommand;
  }
  namespace FindCommissionerByDeviceType {
  using Type = struct FindCommissionerByDeviceTypeCommand;
  }
  namespace DiscoveryCommandResponse {
  using DecodableType = struct DiscoveryCommandResponse;
  }
  } // namespace Commands
  } // namespace DiscoveryCommands
  
  namespace LogCommands {
  namespace Commands {
  namespace Log {
  using Type = struct LogCommand;
  }
  namespace UserPrompt {
  using Type = struct UserPromptCommand;
  }
  } // namespace Commands
  } // namespace LogCommands
  
  namespace SystemCommands {
  namespace Commands {
  namespace Start {
  using Type = struct StartCommand;
  }
  namespace Stop {
  using Type = struct StopCommand;
  }
  namespace Reboot {
  using Type = struct RebootCommand;
  }
  namespace FactoryReset {
  using Type = struct FactoryResetCommand;
  }
  namespace CreateOtaImage {
  using Type = struct CreateOtaImageCommand;
  }
  namespace CompareFiles {
  using Type = struct CompareFilesCommand;
  }
  } // namespace Commands
  } // namespace SystemCommands
  
  } // namespace Clusters
  } // namespace app
  
  } // namespace chip
  