zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp

/*
 *
 *    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-common/zap-generated/cluster-objects.h>
#include <app/data-model/WrappedStructEncoder.h>

#include <variant>

namespace chip {
namespace app {
namespace Clusters {

namespace detail {

class StructDecodeIterator
{
public:
    // may return a context tag, a CHIP_ERROR (end iteration)
    using EntryElement = std::variant<uint8_t, CHIP_ERROR>;

    StructDecodeIterator(TLV::TLVReader & reader) : mReader(reader) {}

    // Iterate through structure elements. Returns one of:
    //   - uint8_t CONTEXT TAG (keep iterating)
    //   - CHIP_ERROR (including CHIP_NO_ERROR) which should be a final
    //     return value (stop iterating)
    EntryElement Next()
    {
        if (!mEntered)
        {
            VerifyOrReturnError(TLV::kTLVType_Structure == mReader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
            ReturnErrorOnFailure(mReader.EnterContainer(mOuter));
            mEntered = true;
        }

        while (true)
        {
            CHIP_ERROR err = mReader.Next();
            if (err != CHIP_NO_ERROR)
            {
                VerifyOrReturnError(err == CHIP_ERROR_END_OF_TLV, err);
                break;
            }

            const TLV::Tag tag = mReader.GetTag();
            if (!TLV::IsContextTag(tag))
            {
                continue;
            }

            // we know context tags are 8-bit
            return static_cast<uint8_t>(TLV::TagNumFromTag(tag));
        }

        return mReader.ExitContainer(mOuter);
    }

private:
    bool mEntered = false;
    TLV::TLVType mOuter;
    TLV::TLVReader & mReader;
};

// Structs shared across multiple clusters.
namespace Structs {

namespace ModeTagStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kMfgCode), mfgCode);
    encoder.Encode(to_underlying(Fields::kValue), value);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kMfgCode))
        {
            err = DataModel::Decode(reader, mfgCode);
        }
        else if (__context_tag == to_underlying(Fields::kValue))
        {
            err = DataModel::Decode(reader, value);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ModeTagStruct

namespace ModeOptionStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kLabel), label);
    encoder.Encode(to_underlying(Fields::kMode), mode);
    encoder.Encode(to_underlying(Fields::kModeTags), modeTags);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kLabel))
        {
            err = DataModel::Decode(reader, label);
        }
        else if (__context_tag == to_underlying(Fields::kMode))
        {
            err = DataModel::Decode(reader, mode);
        }
        else if (__context_tag == to_underlying(Fields::kModeTags))
        {
            err = DataModel::Decode(reader, modeTags);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ModeOptionStruct

namespace MeasurementAccuracyRangeStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kRangeMin), rangeMin);
    encoder.Encode(to_underlying(Fields::kRangeMax), rangeMax);
    encoder.Encode(to_underlying(Fields::kPercentMax), percentMax);
    encoder.Encode(to_underlying(Fields::kPercentMin), percentMin);
    encoder.Encode(to_underlying(Fields::kPercentTypical), percentTypical);
    encoder.Encode(to_underlying(Fields::kFixedMax), fixedMax);
    encoder.Encode(to_underlying(Fields::kFixedMin), fixedMin);
    encoder.Encode(to_underlying(Fields::kFixedTypical), fixedTypical);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kRangeMin))
        {
            err = DataModel::Decode(reader, rangeMin);
        }
        else if (__context_tag == to_underlying(Fields::kRangeMax))
        {
            err = DataModel::Decode(reader, rangeMax);
        }
        else if (__context_tag == to_underlying(Fields::kPercentMax))
        {
            err = DataModel::Decode(reader, percentMax);
        }
        else if (__context_tag == to_underlying(Fields::kPercentMin))
        {
            err = DataModel::Decode(reader, percentMin);
        }
        else if (__context_tag == to_underlying(Fields::kPercentTypical))
        {
            err = DataModel::Decode(reader, percentTypical);
        }
        else if (__context_tag == to_underlying(Fields::kFixedMax))
        {
            err = DataModel::Decode(reader, fixedMax);
        }
        else if (__context_tag == to_underlying(Fields::kFixedMin))
        {
            err = DataModel::Decode(reader, fixedMin);
        }
        else if (__context_tag == to_underlying(Fields::kFixedTypical))
        {
            err = DataModel::Decode(reader, fixedTypical);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace MeasurementAccuracyRangeStruct

namespace MeasurementAccuracyStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kMeasurementType), measurementType);
    encoder.Encode(to_underlying(Fields::kMeasured), measured);
    encoder.Encode(to_underlying(Fields::kMinMeasuredValue), minMeasuredValue);
    encoder.Encode(to_underlying(Fields::kMaxMeasuredValue), maxMeasuredValue);
    encoder.Encode(to_underlying(Fields::kAccuracyRanges), accuracyRanges);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kMeasurementType))
        {
            err = DataModel::Decode(reader, measurementType);
        }
        else if (__context_tag == to_underlying(Fields::kMeasured))
        {
            err = DataModel::Decode(reader, measured);
        }
        else if (__context_tag == to_underlying(Fields::kMinMeasuredValue))
        {
            err = DataModel::Decode(reader, minMeasuredValue);
        }
        else if (__context_tag == to_underlying(Fields::kMaxMeasuredValue))
        {
            err = DataModel::Decode(reader, maxMeasuredValue);
        }
        else if (__context_tag == to_underlying(Fields::kAccuracyRanges))
        {
            err = DataModel::Decode(reader, accuracyRanges);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace MeasurementAccuracyStruct

namespace DeviceTypeStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kDeviceType), deviceType);
    encoder.Encode(to_underlying(Fields::kRevision), revision);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kDeviceType))
        {
            err = DataModel::Decode(reader, deviceType);
        }
        else if (__context_tag == to_underlying(Fields::kRevision))
        {
            err = DataModel::Decode(reader, revision);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace DeviceTypeStruct

namespace ApplicationStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kCatalogVendorID), catalogVendorID);
    encoder.Encode(to_underlying(Fields::kApplicationID), applicationID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCatalogVendorID))
        {
            err = DataModel::Decode(reader, catalogVendorID);
        }
        else if (__context_tag == to_underlying(Fields::kApplicationID))
        {
            err = DataModel::Decode(reader, applicationID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ApplicationStruct

namespace ErrorStateStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kErrorStateID), errorStateID);
    encoder.Encode(to_underlying(Fields::kErrorStateLabel), errorStateLabel);
    encoder.Encode(to_underlying(Fields::kErrorStateDetails), errorStateDetails);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kErrorStateID))
        {
            err = DataModel::Decode(reader, errorStateID);
        }
        else if (__context_tag == to_underlying(Fields::kErrorStateLabel))
        {
            err = DataModel::Decode(reader, errorStateLabel);
        }
        else if (__context_tag == to_underlying(Fields::kErrorStateDetails))
        {
            err = DataModel::Decode(reader, errorStateDetails);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ErrorStateStruct

namespace ICEServerStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kUrls), urls);
    encoder.Encode(to_underlying(Fields::kUsername), username);
    encoder.Encode(to_underlying(Fields::kCredential), credential);
    encoder.Encode(to_underlying(Fields::kCaid), caid);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kUrls))
        {
            err = DataModel::Decode(reader, urls);
        }
        else if (__context_tag == to_underlying(Fields::kUsername))
        {
            err = DataModel::Decode(reader, username);
        }
        else if (__context_tag == to_underlying(Fields::kCredential))
        {
            err = DataModel::Decode(reader, credential);
        }
        else if (__context_tag == to_underlying(Fields::kCaid))
        {
            err = DataModel::Decode(reader, caid);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ICEServerStruct

namespace LabelStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kLabel), label);
    encoder.Encode(to_underlying(Fields::kValue), value);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kLabel))
        {
            err = DataModel::Decode(reader, label);
        }
        else if (__context_tag == to_underlying(Fields::kValue))
        {
            err = DataModel::Decode(reader, value);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace LabelStruct

namespace OperationalStateStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kOperationalStateID), operationalStateID);
    encoder.Encode(to_underlying(Fields::kOperationalStateLabel), operationalStateLabel);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kOperationalStateID))
        {
            err = DataModel::Decode(reader, operationalStateID);
        }
        else if (__context_tag == to_underlying(Fields::kOperationalStateLabel))
        {
            err = DataModel::Decode(reader, operationalStateLabel);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace OperationalStateStruct

namespace ViewportStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kX1), x1);
    encoder.Encode(to_underlying(Fields::kY1), y1);
    encoder.Encode(to_underlying(Fields::kX2), x2);
    encoder.Encode(to_underlying(Fields::kY2), y2);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kX1))
        {
            err = DataModel::Decode(reader, x1);
        }
        else if (__context_tag == to_underlying(Fields::kY1))
        {
            err = DataModel::Decode(reader, y1);
        }
        else if (__context_tag == to_underlying(Fields::kX2))
        {
            err = DataModel::Decode(reader, x2);
        }
        else if (__context_tag == to_underlying(Fields::kY2))
        {
            err = DataModel::Decode(reader, y2);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ViewportStruct

namespace WebRTCSessionStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kId), id);
    encoder.Encode(to_underlying(Fields::kPeerNodeID), peerNodeID);
    encoder.Encode(to_underlying(Fields::kPeerFabricIndex), peerFabricIndex);
    encoder.Encode(to_underlying(Fields::kStreamType), streamType);
    encoder.Encode(to_underlying(Fields::kVideoStreamID), videoStreamID);
    encoder.Encode(to_underlying(Fields::kAudioStreamID), audioStreamID);
    encoder.Encode(to_underlying(Fields::kMetadataOptions), metadataOptions);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kId))
        {
            err = DataModel::Decode(reader, id);
        }
        else if (__context_tag == to_underlying(Fields::kPeerNodeID))
        {
            err = DataModel::Decode(reader, peerNodeID);
        }
        else if (__context_tag == to_underlying(Fields::kPeerFabricIndex))
        {
            err = DataModel::Decode(reader, peerFabricIndex);
        }
        else if (__context_tag == to_underlying(Fields::kStreamType))
        {
            err = DataModel::Decode(reader, streamType);
        }
        else if (__context_tag == to_underlying(Fields::kVideoStreamID))
        {
            err = DataModel::Decode(reader, videoStreamID);
        }
        else if (__context_tag == to_underlying(Fields::kAudioStreamID))
        {
            err = DataModel::Decode(reader, audioStreamID);
        }
        else if (__context_tag == to_underlying(Fields::kMetadataOptions))
        {
            err = DataModel::Decode(reader, metadataOptions);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace WebRTCSessionStruct
} // namespace Structs
} // namespace detail

namespace Globals {
// Global structs
namespace Structs {

namespace TestGlobalStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kName), name);
    encoder.Encode(to_underlying(Fields::kMyBitmap), myBitmap);
    encoder.Encode(to_underlying(Fields::kMyEnum), myEnum);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kName))
        {
            err = DataModel::Decode(reader, name);
        }
        else if (__context_tag == to_underlying(Fields::kMyBitmap))
        {
            err = DataModel::Decode(reader, myBitmap);
        }
        else if (__context_tag == to_underlying(Fields::kMyEnum))
        {
            err = DataModel::Decode(reader, myEnum);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace TestGlobalStruct

namespace LocationDescriptorStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kLocationName), locationName);
    encoder.Encode(to_underlying(Fields::kFloorNumber), floorNumber);
    encoder.Encode(to_underlying(Fields::kAreaType), areaType);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kLocationName))
        {
            err = DataModel::Decode(reader, locationName);
        }
        else if (__context_tag == to_underlying(Fields::kFloorNumber))
        {
            err = DataModel::Decode(reader, floorNumber);
        }
        else if (__context_tag == to_underlying(Fields::kAreaType))
        {
            err = DataModel::Decode(reader, areaType);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace LocationDescriptorStruct

namespace AtomicAttributeStatusStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kAttributeID), attributeID);
    encoder.Encode(to_underlying(Fields::kStatusCode), statusCode);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kAttributeID))
        {
            err = DataModel::Decode(reader, attributeID);
        }
        else if (__context_tag == to_underlying(Fields::kStatusCode))
        {
            err = DataModel::Decode(reader, statusCode);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace AtomicAttributeStatusStruct

} // namespace Structs
} // namespace Globals

namespace Identify {

namespace Commands {
namespace Identify {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kIdentifyTime), identifyTime);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kIdentifyTime))
        {
            err = DataModel::Decode(reader, identifyTime);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace Identify.
namespace TriggerEffect {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kEffectIdentifier), effectIdentifier);
    encoder.Encode(to_underlying(Fields::kEffectVariant), effectVariant);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kEffectIdentifier))
        {
            err = DataModel::Decode(reader, effectIdentifier);
        }
        else if (__context_tag == to_underlying(Fields::kEffectVariant))
        {
            err = DataModel::Decode(reader, effectVariant);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TriggerEffect.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::IdentifyTime::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, identifyTime);
    case Attributes::IdentifyType::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, identifyType);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace Identify
namespace Groups {

namespace Commands {
namespace AddGroup {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kGroupID), groupID);
    encoder.Encode(to_underlying(Fields::kGroupName), groupName);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kGroupID))
        {
            err = DataModel::Decode(reader, groupID);
        }
        else if (__context_tag == to_underlying(Fields::kGroupName))
        {
            err = DataModel::Decode(reader, groupName);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace AddGroup.
namespace AddGroupResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kGroupID), groupID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kGroupID))
        {
            err = DataModel::Decode(reader, groupID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace AddGroupResponse.
namespace ViewGroup {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kGroupID), groupID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kGroupID))
        {
            err = DataModel::Decode(reader, groupID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ViewGroup.
namespace ViewGroupResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kGroupID), groupID);
    encoder.Encode(to_underlying(Fields::kGroupName), groupName);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kGroupID))
        {
            err = DataModel::Decode(reader, groupID);
        }
        else if (__context_tag == to_underlying(Fields::kGroupName))
        {
            err = DataModel::Decode(reader, groupName);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ViewGroupResponse.
namespace GetGroupMembership {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kGroupList), groupList);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kGroupList))
        {
            err = DataModel::Decode(reader, groupList);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GetGroupMembership.
namespace GetGroupMembershipResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kCapacity), capacity);
    encoder.Encode(to_underlying(Fields::kGroupList), groupList);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCapacity))
        {
            err = DataModel::Decode(reader, capacity);
        }
        else if (__context_tag == to_underlying(Fields::kGroupList))
        {
            err = DataModel::Decode(reader, groupList);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GetGroupMembershipResponse.
namespace RemoveGroup {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kGroupID), groupID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kGroupID))
        {
            err = DataModel::Decode(reader, groupID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace RemoveGroup.
namespace RemoveGroupResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kGroupID), groupID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kGroupID))
        {
            err = DataModel::Decode(reader, groupID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace RemoveGroupResponse.
namespace RemoveAllGroups {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace RemoveAllGroups.
namespace AddGroupIfIdentifying {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kGroupID), groupID);
    encoder.Encode(to_underlying(Fields::kGroupName), groupName);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kGroupID))
        {
            err = DataModel::Decode(reader, groupID);
        }
        else if (__context_tag == to_underlying(Fields::kGroupName))
        {
            err = DataModel::Decode(reader, groupName);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace AddGroupIfIdentifying.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::NameSupport::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nameSupport);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace Groups
namespace OnOff {

namespace Commands {
namespace Off {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace Off.
namespace On {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace On.
namespace Toggle {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace Toggle.
namespace OffWithEffect {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kEffectIdentifier), effectIdentifier);
    encoder.Encode(to_underlying(Fields::kEffectVariant), effectVariant);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kEffectIdentifier))
        {
            err = DataModel::Decode(reader, effectIdentifier);
        }
        else if (__context_tag == to_underlying(Fields::kEffectVariant))
        {
            err = DataModel::Decode(reader, effectVariant);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace OffWithEffect.
namespace OnWithRecallGlobalScene {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace OnWithRecallGlobalScene.
namespace OnWithTimedOff {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kOnOffControl), onOffControl);
    encoder.Encode(to_underlying(Fields::kOnTime), onTime);
    encoder.Encode(to_underlying(Fields::kOffWaitTime), offWaitTime);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kOnOffControl))
        {
            err = DataModel::Decode(reader, onOffControl);
        }
        else if (__context_tag == to_underlying(Fields::kOnTime))
        {
            err = DataModel::Decode(reader, onTime);
        }
        else if (__context_tag == to_underlying(Fields::kOffWaitTime))
        {
            err = DataModel::Decode(reader, offWaitTime);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace OnWithTimedOff.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::OnOff::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, onOff);
    case Attributes::GlobalSceneControl::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, globalSceneControl);
    case Attributes::OnTime::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, onTime);
    case Attributes::OffWaitTime::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, offWaitTime);
    case Attributes::StartUpOnOff::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, startUpOnOff);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace OnOff
namespace LevelControl {

namespace Commands {
namespace MoveToLevel {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kLevel), level);
    encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
    encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
    encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kLevel))
        {
            err = DataModel::Decode(reader, level);
        }
        else if (__context_tag == to_underlying(Fields::kTransitionTime))
        {
            err = DataModel::Decode(reader, transitionTime);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsMask))
        {
            err = DataModel::Decode(reader, optionsMask);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsOverride))
        {
            err = DataModel::Decode(reader, optionsOverride);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace MoveToLevel.
namespace Move {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kMoveMode), moveMode);
    encoder.Encode(to_underlying(Fields::kRate), rate);
    encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
    encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kMoveMode))
        {
            err = DataModel::Decode(reader, moveMode);
        }
        else if (__context_tag == to_underlying(Fields::kRate))
        {
            err = DataModel::Decode(reader, rate);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsMask))
        {
            err = DataModel::Decode(reader, optionsMask);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsOverride))
        {
            err = DataModel::Decode(reader, optionsOverride);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace Move.
namespace Step {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStepMode), stepMode);
    encoder.Encode(to_underlying(Fields::kStepSize), stepSize);
    encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
    encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
    encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStepMode))
        {
            err = DataModel::Decode(reader, stepMode);
        }
        else if (__context_tag == to_underlying(Fields::kStepSize))
        {
            err = DataModel::Decode(reader, stepSize);
        }
        else if (__context_tag == to_underlying(Fields::kTransitionTime))
        {
            err = DataModel::Decode(reader, transitionTime);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsMask))
        {
            err = DataModel::Decode(reader, optionsMask);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsOverride))
        {
            err = DataModel::Decode(reader, optionsOverride);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace Step.
namespace Stop {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
    encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kOptionsMask))
        {
            err = DataModel::Decode(reader, optionsMask);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsOverride))
        {
            err = DataModel::Decode(reader, optionsOverride);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace Stop.
namespace MoveToLevelWithOnOff {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kLevel), level);
    encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
    encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
    encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kLevel))
        {
            err = DataModel::Decode(reader, level);
        }
        else if (__context_tag == to_underlying(Fields::kTransitionTime))
        {
            err = DataModel::Decode(reader, transitionTime);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsMask))
        {
            err = DataModel::Decode(reader, optionsMask);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsOverride))
        {
            err = DataModel::Decode(reader, optionsOverride);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace MoveToLevelWithOnOff.
namespace MoveWithOnOff {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kMoveMode), moveMode);
    encoder.Encode(to_underlying(Fields::kRate), rate);
    encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
    encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kMoveMode))
        {
            err = DataModel::Decode(reader, moveMode);
        }
        else if (__context_tag == to_underlying(Fields::kRate))
        {
            err = DataModel::Decode(reader, rate);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsMask))
        {
            err = DataModel::Decode(reader, optionsMask);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsOverride))
        {
            err = DataModel::Decode(reader, optionsOverride);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace MoveWithOnOff.
namespace StepWithOnOff {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStepMode), stepMode);
    encoder.Encode(to_underlying(Fields::kStepSize), stepSize);
    encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
    encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
    encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStepMode))
        {
            err = DataModel::Decode(reader, stepMode);
        }
        else if (__context_tag == to_underlying(Fields::kStepSize))
        {
            err = DataModel::Decode(reader, stepSize);
        }
        else if (__context_tag == to_underlying(Fields::kTransitionTime))
        {
            err = DataModel::Decode(reader, transitionTime);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsMask))
        {
            err = DataModel::Decode(reader, optionsMask);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsOverride))
        {
            err = DataModel::Decode(reader, optionsOverride);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace StepWithOnOff.
namespace StopWithOnOff {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
    encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kOptionsMask))
        {
            err = DataModel::Decode(reader, optionsMask);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsOverride))
        {
            err = DataModel::Decode(reader, optionsOverride);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace StopWithOnOff.
namespace MoveToClosestFrequency {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kFrequency), frequency);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kFrequency))
        {
            err = DataModel::Decode(reader, frequency);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace MoveToClosestFrequency.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::CurrentLevel::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentLevel);
    case Attributes::RemainingTime::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, remainingTime);
    case Attributes::MinLevel::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, minLevel);
    case Attributes::MaxLevel::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxLevel);
    case Attributes::CurrentFrequency::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentFrequency);
    case Attributes::MinFrequency::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, minFrequency);
    case Attributes::MaxFrequency::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxFrequency);
    case Attributes::Options::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, options);
    case Attributes::OnOffTransitionTime::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, onOffTransitionTime);
    case Attributes::OnLevel::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, onLevel);
    case Attributes::OnTransitionTime::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, onTransitionTime);
    case Attributes::OffTransitionTime::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, offTransitionTime);
    case Attributes::DefaultMoveRate::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, defaultMoveRate);
    case Attributes::StartUpCurrentLevel::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, startUpCurrentLevel);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace LevelControl
namespace PulseWidthModulation {

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace PulseWidthModulation
namespace Descriptor {
namespace Structs {

namespace SemanticTagStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kMfgCode), mfgCode);
    encoder.Encode(to_underlying(Fields::kNamespaceID), namespaceID);
    encoder.Encode(to_underlying(Fields::kTag), tag);
    encoder.Encode(to_underlying(Fields::kLabel), label);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kMfgCode))
        {
            err = DataModel::Decode(reader, mfgCode);
        }
        else if (__context_tag == to_underlying(Fields::kNamespaceID))
        {
            err = DataModel::Decode(reader, namespaceID);
        }
        else if (__context_tag == to_underlying(Fields::kTag))
        {
            err = DataModel::Decode(reader, tag);
        }
        else if (__context_tag == to_underlying(Fields::kLabel))
        {
            err = DataModel::Decode(reader, label);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace SemanticTagStruct
} // namespace Structs

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::DeviceTypeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, deviceTypeList);
    case Attributes::ServerList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, serverList);
    case Attributes::ClientList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clientList);
    case Attributes::PartsList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, partsList);
    case Attributes::TagList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, tagList);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace Descriptor
namespace Binding {
namespace Structs {

namespace TargetStruct {
CHIP_ERROR Type::EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    return DoEncode(aWriter, aTag, NullOptional);
}

CHIP_ERROR Type::EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const
{
    return DoEncode(aWriter, aTag, MakeOptional(aAccessingFabricIndex));
}

CHIP_ERROR Type::DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const
{

    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };

    encoder.Encode(to_underlying(Fields::kNode), node);
    encoder.Encode(to_underlying(Fields::kGroup), group);
    encoder.Encode(to_underlying(Fields::kEndpoint), endpoint);
    encoder.Encode(to_underlying(Fields::kCluster), cluster);
    if (aAccessingFabricIndex.HasValue())
    {
        encoder.Encode(to_underlying(Fields::kFabricIndex), fabricIndex);
    }

    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNode))
        {
            err = DataModel::Decode(reader, node);
        }
        else if (__context_tag == to_underlying(Fields::kGroup))
        {
            err = DataModel::Decode(reader, group);
        }
        else if (__context_tag == to_underlying(Fields::kEndpoint))
        {
            err = DataModel::Decode(reader, endpoint);
        }
        else if (__context_tag == to_underlying(Fields::kCluster))
        {
            err = DataModel::Decode(reader, cluster);
        }
        else if (__context_tag == to_underlying(Fields::kFabricIndex))
        {
            err = DataModel::Decode(reader, fabricIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace TargetStruct
} // namespace Structs

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::Binding::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, binding);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace Binding
namespace AccessControl {
namespace Structs {

namespace AccessRestrictionStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kType), type);
    encoder.Encode(to_underlying(Fields::kId), id);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kType))
        {
            err = DataModel::Decode(reader, type);
        }
        else if (__context_tag == to_underlying(Fields::kId))
        {
            err = DataModel::Decode(reader, id);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace AccessRestrictionStruct

namespace CommissioningAccessRestrictionEntryStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kEndpoint), endpoint);
    encoder.Encode(to_underlying(Fields::kCluster), cluster);
    encoder.Encode(to_underlying(Fields::kRestrictions), restrictions);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kEndpoint))
        {
            err = DataModel::Decode(reader, endpoint);
        }
        else if (__context_tag == to_underlying(Fields::kCluster))
        {
            err = DataModel::Decode(reader, cluster);
        }
        else if (__context_tag == to_underlying(Fields::kRestrictions))
        {
            err = DataModel::Decode(reader, restrictions);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace CommissioningAccessRestrictionEntryStruct

namespace AccessRestrictionEntryStruct {
CHIP_ERROR Type::EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    return DoEncode(aWriter, aTag, NullOptional);
}

CHIP_ERROR Type::EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const
{
    return DoEncode(aWriter, aTag, MakeOptional(aAccessingFabricIndex));
}

CHIP_ERROR Type::DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const
{
    bool includeSensitive = !aAccessingFabricIndex.HasValue() || (aAccessingFabricIndex.Value() == fabricIndex);

    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };

    if (includeSensitive)
    {
        encoder.Encode(to_underlying(Fields::kEndpoint), endpoint);
    }
    if (includeSensitive)
    {
        encoder.Encode(to_underlying(Fields::kCluster), cluster);
    }
    if (includeSensitive)
    {
        encoder.Encode(to_underlying(Fields::kRestrictions), restrictions);
    }
    if (aAccessingFabricIndex.HasValue())
    {
        encoder.Encode(to_underlying(Fields::kFabricIndex), fabricIndex);
    }

    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kEndpoint))
        {
            err = DataModel::Decode(reader, endpoint);
        }
        else if (__context_tag == to_underlying(Fields::kCluster))
        {
            err = DataModel::Decode(reader, cluster);
        }
        else if (__context_tag == to_underlying(Fields::kRestrictions))
        {
            err = DataModel::Decode(reader, restrictions);
        }
        else if (__context_tag == to_underlying(Fields::kFabricIndex))
        {
            err = DataModel::Decode(reader, fabricIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace AccessRestrictionEntryStruct

namespace AccessControlTargetStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kCluster), cluster);
    encoder.Encode(to_underlying(Fields::kEndpoint), endpoint);
    encoder.Encode(to_underlying(Fields::kDeviceType), deviceType);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCluster))
        {
            err = DataModel::Decode(reader, cluster);
        }
        else if (__context_tag == to_underlying(Fields::kEndpoint))
        {
            err = DataModel::Decode(reader, endpoint);
        }
        else if (__context_tag == to_underlying(Fields::kDeviceType))
        {
            err = DataModel::Decode(reader, deviceType);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace AccessControlTargetStruct

namespace AccessControlEntryStruct {
CHIP_ERROR Type::EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    return DoEncode(aWriter, aTag, NullOptional);
}

CHIP_ERROR Type::EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const
{
    return DoEncode(aWriter, aTag, MakeOptional(aAccessingFabricIndex));
}

CHIP_ERROR Type::DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const
{
    bool includeSensitive = !aAccessingFabricIndex.HasValue() || (aAccessingFabricIndex.Value() == fabricIndex);

    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };

    if (includeSensitive)
    {
        encoder.Encode(to_underlying(Fields::kPrivilege), privilege);
    }
    if (includeSensitive)
    {
        encoder.Encode(to_underlying(Fields::kAuthMode), authMode);
    }
    if (includeSensitive)
    {
        encoder.Encode(to_underlying(Fields::kSubjects), subjects);
    }
    if (includeSensitive)
    {
        encoder.Encode(to_underlying(Fields::kTargets), targets);
    }
    if (aAccessingFabricIndex.HasValue())
    {
        encoder.Encode(to_underlying(Fields::kFabricIndex), fabricIndex);
    }

    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kPrivilege))
        {
            err = DataModel::Decode(reader, privilege);
        }
        else if (__context_tag == to_underlying(Fields::kAuthMode))
        {
            err = DataModel::Decode(reader, authMode);
        }
        else if (__context_tag == to_underlying(Fields::kSubjects))
        {
            err = DataModel::Decode(reader, subjects);
        }
        else if (__context_tag == to_underlying(Fields::kTargets))
        {
            err = DataModel::Decode(reader, targets);
        }
        else if (__context_tag == to_underlying(Fields::kFabricIndex))
        {
            err = DataModel::Decode(reader, fabricIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace AccessControlEntryStruct

namespace AccessControlExtensionStruct {
CHIP_ERROR Type::EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    return DoEncode(aWriter, aTag, NullOptional);
}

CHIP_ERROR Type::EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const
{
    return DoEncode(aWriter, aTag, MakeOptional(aAccessingFabricIndex));
}

CHIP_ERROR Type::DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const
{
    bool includeSensitive = !aAccessingFabricIndex.HasValue() || (aAccessingFabricIndex.Value() == fabricIndex);

    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };

    if (includeSensitive)
    {
        encoder.Encode(to_underlying(Fields::kData), data);
    }
    if (aAccessingFabricIndex.HasValue())
    {
        encoder.Encode(to_underlying(Fields::kFabricIndex), fabricIndex);
    }

    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kData))
        {
            err = DataModel::Decode(reader, data);
        }
        else if (__context_tag == to_underlying(Fields::kFabricIndex))
        {
            err = DataModel::Decode(reader, fabricIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace AccessControlExtensionStruct
} // namespace Structs

namespace Commands {
namespace ReviewFabricRestrictions {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kArl), arl);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kArl))
        {
            err = DataModel::Decode(reader, arl);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ReviewFabricRestrictions.
namespace ReviewFabricRestrictionsResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kToken), token);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kToken))
        {
            err = DataModel::Decode(reader, token);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ReviewFabricRestrictionsResponse.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::Acl::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acl);
    case Attributes::Extension::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, extension);
    case Attributes::SubjectsPerAccessControlEntry::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, subjectsPerAccessControlEntry);
    case Attributes::TargetsPerAccessControlEntry::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, targetsPerAccessControlEntry);
    case Attributes::AccessControlEntriesPerFabric::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, accessControlEntriesPerFabric);
    case Attributes::CommissioningARL::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, commissioningARL);
    case Attributes::Arl::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, arl);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace AccessControlEntryChanged {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAdminNodeID), adminNodeID));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAdminPasscodeID), adminPasscodeID));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kChangeType), changeType));
    ReturnErrorOnFailure(DataModel::EncodeForRead(aWriter, TLV::ContextTag(Fields::kLatestValue), GetFabricIndex(), latestValue));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kFabricIndex), fabricIndex));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kAdminNodeID))
        {
            err = DataModel::Decode(reader, adminNodeID);
        }
        else if (__context_tag == to_underlying(Fields::kAdminPasscodeID))
        {
            err = DataModel::Decode(reader, adminPasscodeID);
        }
        else if (__context_tag == to_underlying(Fields::kChangeType))
        {
            err = DataModel::Decode(reader, changeType);
        }
        else if (__context_tag == to_underlying(Fields::kLatestValue))
        {
            err = DataModel::Decode(reader, latestValue);
        }
        else if (__context_tag == to_underlying(Fields::kFabricIndex))
        {
            err = DataModel::Decode(reader, fabricIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace AccessControlEntryChanged.
namespace AccessControlExtensionChanged {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAdminNodeID), adminNodeID));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAdminPasscodeID), adminPasscodeID));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kChangeType), changeType));
    ReturnErrorOnFailure(DataModel::EncodeForRead(aWriter, TLV::ContextTag(Fields::kLatestValue), GetFabricIndex(), latestValue));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kFabricIndex), fabricIndex));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kAdminNodeID))
        {
            err = DataModel::Decode(reader, adminNodeID);
        }
        else if (__context_tag == to_underlying(Fields::kAdminPasscodeID))
        {
            err = DataModel::Decode(reader, adminPasscodeID);
        }
        else if (__context_tag == to_underlying(Fields::kChangeType))
        {
            err = DataModel::Decode(reader, changeType);
        }
        else if (__context_tag == to_underlying(Fields::kLatestValue))
        {
            err = DataModel::Decode(reader, latestValue);
        }
        else if (__context_tag == to_underlying(Fields::kFabricIndex))
        {
            err = DataModel::Decode(reader, fabricIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace AccessControlExtensionChanged.
namespace FabricRestrictionReviewUpdate {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kToken), token));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kInstruction), instruction));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kARLRequestFlowUrl), ARLRequestFlowUrl));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kFabricIndex), fabricIndex));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kToken))
        {
            err = DataModel::Decode(reader, token);
        }
        else if (__context_tag == to_underlying(Fields::kInstruction))
        {
            err = DataModel::Decode(reader, instruction);
        }
        else if (__context_tag == to_underlying(Fields::kARLRequestFlowUrl))
        {
            err = DataModel::Decode(reader, ARLRequestFlowUrl);
        }
        else if (__context_tag == to_underlying(Fields::kFabricIndex))
        {
            err = DataModel::Decode(reader, fabricIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace FabricRestrictionReviewUpdate.
} // namespace Events

} // namespace AccessControl
namespace Actions {
namespace Structs {

namespace ActionStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kActionID), actionID);
    encoder.Encode(to_underlying(Fields::kName), name);
    encoder.Encode(to_underlying(Fields::kType), type);
    encoder.Encode(to_underlying(Fields::kEndpointListID), endpointListID);
    encoder.Encode(to_underlying(Fields::kSupportedCommands), supportedCommands);
    encoder.Encode(to_underlying(Fields::kState), state);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kActionID))
        {
            err = DataModel::Decode(reader, actionID);
        }
        else if (__context_tag == to_underlying(Fields::kName))
        {
            err = DataModel::Decode(reader, name);
        }
        else if (__context_tag == to_underlying(Fields::kType))
        {
            err = DataModel::Decode(reader, type);
        }
        else if (__context_tag == to_underlying(Fields::kEndpointListID))
        {
            err = DataModel::Decode(reader, endpointListID);
        }
        else if (__context_tag == to_underlying(Fields::kSupportedCommands))
        {
            err = DataModel::Decode(reader, supportedCommands);
        }
        else if (__context_tag == to_underlying(Fields::kState))
        {
            err = DataModel::Decode(reader, state);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ActionStruct

namespace EndpointListStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kEndpointListID), endpointListID);
    encoder.Encode(to_underlying(Fields::kName), name);
    encoder.Encode(to_underlying(Fields::kType), type);
    encoder.Encode(to_underlying(Fields::kEndpoints), endpoints);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kEndpointListID))
        {
            err = DataModel::Decode(reader, endpointListID);
        }
        else if (__context_tag == to_underlying(Fields::kName))
        {
            err = DataModel::Decode(reader, name);
        }
        else if (__context_tag == to_underlying(Fields::kType))
        {
            err = DataModel::Decode(reader, type);
        }
        else if (__context_tag == to_underlying(Fields::kEndpoints))
        {
            err = DataModel::Decode(reader, endpoints);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace EndpointListStruct
} // namespace Structs

namespace Commands {
namespace InstantAction {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kActionID), actionID);
    encoder.Encode(to_underlying(Fields::kInvokeID), invokeID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kActionID))
        {
            err = DataModel::Decode(reader, actionID);
        }
        else if (__context_tag == to_underlying(Fields::kInvokeID))
        {
            err = DataModel::Decode(reader, invokeID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace InstantAction.
namespace InstantActionWithTransition {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kActionID), actionID);
    encoder.Encode(to_underlying(Fields::kInvokeID), invokeID);
    encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kActionID))
        {
            err = DataModel::Decode(reader, actionID);
        }
        else if (__context_tag == to_underlying(Fields::kInvokeID))
        {
            err = DataModel::Decode(reader, invokeID);
        }
        else if (__context_tag == to_underlying(Fields::kTransitionTime))
        {
            err = DataModel::Decode(reader, transitionTime);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace InstantActionWithTransition.
namespace StartAction {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kActionID), actionID);
    encoder.Encode(to_underlying(Fields::kInvokeID), invokeID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kActionID))
        {
            err = DataModel::Decode(reader, actionID);
        }
        else if (__context_tag == to_underlying(Fields::kInvokeID))
        {
            err = DataModel::Decode(reader, invokeID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace StartAction.
namespace StartActionWithDuration {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kActionID), actionID);
    encoder.Encode(to_underlying(Fields::kInvokeID), invokeID);
    encoder.Encode(to_underlying(Fields::kDuration), duration);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kActionID))
        {
            err = DataModel::Decode(reader, actionID);
        }
        else if (__context_tag == to_underlying(Fields::kInvokeID))
        {
            err = DataModel::Decode(reader, invokeID);
        }
        else if (__context_tag == to_underlying(Fields::kDuration))
        {
            err = DataModel::Decode(reader, duration);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace StartActionWithDuration.
namespace StopAction {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kActionID), actionID);
    encoder.Encode(to_underlying(Fields::kInvokeID), invokeID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kActionID))
        {
            err = DataModel::Decode(reader, actionID);
        }
        else if (__context_tag == to_underlying(Fields::kInvokeID))
        {
            err = DataModel::Decode(reader, invokeID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace StopAction.
namespace PauseAction {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kActionID), actionID);
    encoder.Encode(to_underlying(Fields::kInvokeID), invokeID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kActionID))
        {
            err = DataModel::Decode(reader, actionID);
        }
        else if (__context_tag == to_underlying(Fields::kInvokeID))
        {
            err = DataModel::Decode(reader, invokeID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace PauseAction.
namespace PauseActionWithDuration {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kActionID), actionID);
    encoder.Encode(to_underlying(Fields::kInvokeID), invokeID);
    encoder.Encode(to_underlying(Fields::kDuration), duration);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kActionID))
        {
            err = DataModel::Decode(reader, actionID);
        }
        else if (__context_tag == to_underlying(Fields::kInvokeID))
        {
            err = DataModel::Decode(reader, invokeID);
        }
        else if (__context_tag == to_underlying(Fields::kDuration))
        {
            err = DataModel::Decode(reader, duration);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace PauseActionWithDuration.
namespace ResumeAction {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kActionID), actionID);
    encoder.Encode(to_underlying(Fields::kInvokeID), invokeID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kActionID))
        {
            err = DataModel::Decode(reader, actionID);
        }
        else if (__context_tag == to_underlying(Fields::kInvokeID))
        {
            err = DataModel::Decode(reader, invokeID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ResumeAction.
namespace EnableAction {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kActionID), actionID);
    encoder.Encode(to_underlying(Fields::kInvokeID), invokeID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kActionID))
        {
            err = DataModel::Decode(reader, actionID);
        }
        else if (__context_tag == to_underlying(Fields::kInvokeID))
        {
            err = DataModel::Decode(reader, invokeID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace EnableAction.
namespace EnableActionWithDuration {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kActionID), actionID);
    encoder.Encode(to_underlying(Fields::kInvokeID), invokeID);
    encoder.Encode(to_underlying(Fields::kDuration), duration);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kActionID))
        {
            err = DataModel::Decode(reader, actionID);
        }
        else if (__context_tag == to_underlying(Fields::kInvokeID))
        {
            err = DataModel::Decode(reader, invokeID);
        }
        else if (__context_tag == to_underlying(Fields::kDuration))
        {
            err = DataModel::Decode(reader, duration);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace EnableActionWithDuration.
namespace DisableAction {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kActionID), actionID);
    encoder.Encode(to_underlying(Fields::kInvokeID), invokeID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kActionID))
        {
            err = DataModel::Decode(reader, actionID);
        }
        else if (__context_tag == to_underlying(Fields::kInvokeID))
        {
            err = DataModel::Decode(reader, invokeID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace DisableAction.
namespace DisableActionWithDuration {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kActionID), actionID);
    encoder.Encode(to_underlying(Fields::kInvokeID), invokeID);
    encoder.Encode(to_underlying(Fields::kDuration), duration);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kActionID))
        {
            err = DataModel::Decode(reader, actionID);
        }
        else if (__context_tag == to_underlying(Fields::kInvokeID))
        {
            err = DataModel::Decode(reader, invokeID);
        }
        else if (__context_tag == to_underlying(Fields::kDuration))
        {
            err = DataModel::Decode(reader, duration);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace DisableActionWithDuration.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::ActionList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, actionList);
    case Attributes::EndpointLists::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, endpointLists);
    case Attributes::SetupURL::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, setupURL);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace StateChanged {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kActionID), actionID));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kInvokeID), invokeID));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kNewState), newState));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kActionID))
        {
            err = DataModel::Decode(reader, actionID);
        }
        else if (__context_tag == to_underlying(Fields::kInvokeID))
        {
            err = DataModel::Decode(reader, invokeID);
        }
        else if (__context_tag == to_underlying(Fields::kNewState))
        {
            err = DataModel::Decode(reader, newState);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace StateChanged.
namespace ActionFailed {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kActionID), actionID));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kInvokeID), invokeID));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kNewState), newState));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kError), error));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kActionID))
        {
            err = DataModel::Decode(reader, actionID);
        }
        else if (__context_tag == to_underlying(Fields::kInvokeID))
        {
            err = DataModel::Decode(reader, invokeID);
        }
        else if (__context_tag == to_underlying(Fields::kNewState))
        {
            err = DataModel::Decode(reader, newState);
        }
        else if (__context_tag == to_underlying(Fields::kError))
        {
            err = DataModel::Decode(reader, error);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ActionFailed.
} // namespace Events

} // namespace Actions
namespace BasicInformation {
namespace Structs {

namespace CapabilityMinimaStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kCaseSessionsPerFabric), caseSessionsPerFabric);
    encoder.Encode(to_underlying(Fields::kSubscriptionsPerFabric), subscriptionsPerFabric);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCaseSessionsPerFabric))
        {
            err = DataModel::Decode(reader, caseSessionsPerFabric);
        }
        else if (__context_tag == to_underlying(Fields::kSubscriptionsPerFabric))
        {
            err = DataModel::Decode(reader, subscriptionsPerFabric);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace CapabilityMinimaStruct

namespace ProductAppearanceStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kFinish), finish);
    encoder.Encode(to_underlying(Fields::kPrimaryColor), primaryColor);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kFinish))
        {
            err = DataModel::Decode(reader, finish);
        }
        else if (__context_tag == to_underlying(Fields::kPrimaryColor))
        {
            err = DataModel::Decode(reader, primaryColor);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ProductAppearanceStruct
} // namespace Structs

namespace Commands {
namespace MfgSpecificPing {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace MfgSpecificPing.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::DataModelRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, dataModelRevision);
    case Attributes::VendorName::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, vendorName);
    case Attributes::VendorID::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, vendorID);
    case Attributes::ProductName::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, productName);
    case Attributes::ProductID::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, productID);
    case Attributes::NodeLabel::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nodeLabel);
    case Attributes::Location::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, location);
    case Attributes::HardwareVersion::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, hardwareVersion);
    case Attributes::HardwareVersionString::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, hardwareVersionString);
    case Attributes::SoftwareVersion::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, softwareVersion);
    case Attributes::SoftwareVersionString::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, softwareVersionString);
    case Attributes::ManufacturingDate::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, manufacturingDate);
    case Attributes::PartNumber::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, partNumber);
    case Attributes::ProductURL::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, productURL);
    case Attributes::ProductLabel::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, productLabel);
    case Attributes::SerialNumber::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, serialNumber);
    case Attributes::LocalConfigDisabled::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, localConfigDisabled);
    case Attributes::Reachable::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, reachable);
    case Attributes::UniqueID::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, uniqueID);
    case Attributes::CapabilityMinima::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, capabilityMinima);
    case Attributes::ProductAppearance::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, productAppearance);
    case Attributes::SpecificationVersion::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, specificationVersion);
    case Attributes::MaxPathsPerInvoke::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxPathsPerInvoke);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace StartUp {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSoftwareVersion), softwareVersion));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kSoftwareVersion))
        {
            err = DataModel::Decode(reader, softwareVersion);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace StartUp.
namespace ShutDown {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace ShutDown.
namespace Leave {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kFabricIndex), fabricIndex));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kFabricIndex))
        {
            err = DataModel::Decode(reader, fabricIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace Leave.
namespace ReachableChanged {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kReachableNewValue), reachableNewValue));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kReachableNewValue))
        {
            err = DataModel::Decode(reader, reachableNewValue);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ReachableChanged.
} // namespace Events

} // namespace BasicInformation
namespace OtaSoftwareUpdateProvider {

namespace Commands {
namespace QueryImage {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kVendorID), vendorID);
    encoder.Encode(to_underlying(Fields::kProductID), productID);
    encoder.Encode(to_underlying(Fields::kSoftwareVersion), softwareVersion);
    encoder.Encode(to_underlying(Fields::kProtocolsSupported), protocolsSupported);
    encoder.Encode(to_underlying(Fields::kHardwareVersion), hardwareVersion);
    encoder.Encode(to_underlying(Fields::kLocation), location);
    encoder.Encode(to_underlying(Fields::kRequestorCanConsent), requestorCanConsent);
    encoder.Encode(to_underlying(Fields::kMetadataForProvider), metadataForProvider);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kVendorID))
        {
            err = DataModel::Decode(reader, vendorID);
        }
        else if (__context_tag == to_underlying(Fields::kProductID))
        {
            err = DataModel::Decode(reader, productID);
        }
        else if (__context_tag == to_underlying(Fields::kSoftwareVersion))
        {
            err = DataModel::Decode(reader, softwareVersion);
        }
        else if (__context_tag == to_underlying(Fields::kProtocolsSupported))
        {
            err = DataModel::Decode(reader, protocolsSupported);
        }
        else if (__context_tag == to_underlying(Fields::kHardwareVersion))
        {
            err = DataModel::Decode(reader, hardwareVersion);
        }
        else if (__context_tag == to_underlying(Fields::kLocation))
        {
            err = DataModel::Decode(reader, location);
        }
        else if (__context_tag == to_underlying(Fields::kRequestorCanConsent))
        {
            err = DataModel::Decode(reader, requestorCanConsent);
        }
        else if (__context_tag == to_underlying(Fields::kMetadataForProvider))
        {
            err = DataModel::Decode(reader, metadataForProvider);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace QueryImage.
namespace QueryImageResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kDelayedActionTime), delayedActionTime);
    encoder.Encode(to_underlying(Fields::kImageURI), imageURI);
    encoder.Encode(to_underlying(Fields::kSoftwareVersion), softwareVersion);
    encoder.Encode(to_underlying(Fields::kSoftwareVersionString), softwareVersionString);
    encoder.Encode(to_underlying(Fields::kUpdateToken), updateToken);
    encoder.Encode(to_underlying(Fields::kUserConsentNeeded), userConsentNeeded);
    encoder.Encode(to_underlying(Fields::kMetadataForRequestor), metadataForRequestor);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kDelayedActionTime))
        {
            err = DataModel::Decode(reader, delayedActionTime);
        }
        else if (__context_tag == to_underlying(Fields::kImageURI))
        {
            err = DataModel::Decode(reader, imageURI);
        }
        else if (__context_tag == to_underlying(Fields::kSoftwareVersion))
        {
            err = DataModel::Decode(reader, softwareVersion);
        }
        else if (__context_tag == to_underlying(Fields::kSoftwareVersionString))
        {
            err = DataModel::Decode(reader, softwareVersionString);
        }
        else if (__context_tag == to_underlying(Fields::kUpdateToken))
        {
            err = DataModel::Decode(reader, updateToken);
        }
        else if (__context_tag == to_underlying(Fields::kUserConsentNeeded))
        {
            err = DataModel::Decode(reader, userConsentNeeded);
        }
        else if (__context_tag == to_underlying(Fields::kMetadataForRequestor))
        {
            err = DataModel::Decode(reader, metadataForRequestor);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace QueryImageResponse.
namespace ApplyUpdateRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kUpdateToken), updateToken);
    encoder.Encode(to_underlying(Fields::kNewVersion), newVersion);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kUpdateToken))
        {
            err = DataModel::Decode(reader, updateToken);
        }
        else if (__context_tag == to_underlying(Fields::kNewVersion))
        {
            err = DataModel::Decode(reader, newVersion);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ApplyUpdateRequest.
namespace ApplyUpdateResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kAction), action);
    encoder.Encode(to_underlying(Fields::kDelayedActionTime), delayedActionTime);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kAction))
        {
            err = DataModel::Decode(reader, action);
        }
        else if (__context_tag == to_underlying(Fields::kDelayedActionTime))
        {
            err = DataModel::Decode(reader, delayedActionTime);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ApplyUpdateResponse.
namespace NotifyUpdateApplied {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kUpdateToken), updateToken);
    encoder.Encode(to_underlying(Fields::kSoftwareVersion), softwareVersion);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kUpdateToken))
        {
            err = DataModel::Decode(reader, updateToken);
        }
        else if (__context_tag == to_underlying(Fields::kSoftwareVersion))
        {
            err = DataModel::Decode(reader, softwareVersion);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace NotifyUpdateApplied.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace OtaSoftwareUpdateProvider
namespace OtaSoftwareUpdateRequestor {
namespace Structs {

namespace ProviderLocation {
CHIP_ERROR Type::EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    return DoEncode(aWriter, aTag, NullOptional);
}

CHIP_ERROR Type::EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const
{
    return DoEncode(aWriter, aTag, MakeOptional(aAccessingFabricIndex));
}

CHIP_ERROR Type::DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const
{

    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };

    encoder.Encode(to_underlying(Fields::kProviderNodeID), providerNodeID);
    encoder.Encode(to_underlying(Fields::kEndpoint), endpoint);
    if (aAccessingFabricIndex.HasValue())
    {
        encoder.Encode(to_underlying(Fields::kFabricIndex), fabricIndex);
    }

    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kProviderNodeID))
        {
            err = DataModel::Decode(reader, providerNodeID);
        }
        else if (__context_tag == to_underlying(Fields::kEndpoint))
        {
            err = DataModel::Decode(reader, endpoint);
        }
        else if (__context_tag == to_underlying(Fields::kFabricIndex))
        {
            err = DataModel::Decode(reader, fabricIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ProviderLocation
} // namespace Structs

namespace Commands {
namespace AnnounceOTAProvider {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kProviderNodeID), providerNodeID);
    encoder.Encode(to_underlying(Fields::kVendorID), vendorID);
    encoder.Encode(to_underlying(Fields::kAnnouncementReason), announcementReason);
    encoder.Encode(to_underlying(Fields::kMetadataForNode), metadataForNode);
    encoder.Encode(to_underlying(Fields::kEndpoint), endpoint);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kProviderNodeID))
        {
            err = DataModel::Decode(reader, providerNodeID);
        }
        else if (__context_tag == to_underlying(Fields::kVendorID))
        {
            err = DataModel::Decode(reader, vendorID);
        }
        else if (__context_tag == to_underlying(Fields::kAnnouncementReason))
        {
            err = DataModel::Decode(reader, announcementReason);
        }
        else if (__context_tag == to_underlying(Fields::kMetadataForNode))
        {
            err = DataModel::Decode(reader, metadataForNode);
        }
        else if (__context_tag == to_underlying(Fields::kEndpoint))
        {
            err = DataModel::Decode(reader, endpoint);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace AnnounceOTAProvider.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::DefaultOTAProviders::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, defaultOTAProviders);
    case Attributes::UpdatePossible::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, updatePossible);
    case Attributes::UpdateState::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, updateState);
    case Attributes::UpdateStateProgress::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, updateStateProgress);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace StateTransition {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPreviousState), previousState));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kNewState), newState));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kReason), reason));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kTargetSoftwareVersion), targetSoftwareVersion));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kPreviousState))
        {
            err = DataModel::Decode(reader, previousState);
        }
        else if (__context_tag == to_underlying(Fields::kNewState))
        {
            err = DataModel::Decode(reader, newState);
        }
        else if (__context_tag == to_underlying(Fields::kReason))
        {
            err = DataModel::Decode(reader, reason);
        }
        else if (__context_tag == to_underlying(Fields::kTargetSoftwareVersion))
        {
            err = DataModel::Decode(reader, targetSoftwareVersion);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace StateTransition.
namespace VersionApplied {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSoftwareVersion), softwareVersion));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kProductID), productID));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kSoftwareVersion))
        {
            err = DataModel::Decode(reader, softwareVersion);
        }
        else if (__context_tag == to_underlying(Fields::kProductID))
        {
            err = DataModel::Decode(reader, productID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace VersionApplied.
namespace DownloadError {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSoftwareVersion), softwareVersion));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kBytesDownloaded), bytesDownloaded));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kProgressPercent), progressPercent));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPlatformCode), platformCode));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kSoftwareVersion))
        {
            err = DataModel::Decode(reader, softwareVersion);
        }
        else if (__context_tag == to_underlying(Fields::kBytesDownloaded))
        {
            err = DataModel::Decode(reader, bytesDownloaded);
        }
        else if (__context_tag == to_underlying(Fields::kProgressPercent))
        {
            err = DataModel::Decode(reader, progressPercent);
        }
        else if (__context_tag == to_underlying(Fields::kPlatformCode))
        {
            err = DataModel::Decode(reader, platformCode);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace DownloadError.
} // namespace Events

} // namespace OtaSoftwareUpdateRequestor
namespace LocalizationConfiguration {

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::ActiveLocale::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, activeLocale);
    case Attributes::SupportedLocales::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, supportedLocales);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace LocalizationConfiguration
namespace TimeFormatLocalization {

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::HourFormat::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, hourFormat);
    case Attributes::ActiveCalendarType::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, activeCalendarType);
    case Attributes::SupportedCalendarTypes::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, supportedCalendarTypes);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace TimeFormatLocalization
namespace UnitLocalization {

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::TemperatureUnit::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, temperatureUnit);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace UnitLocalization
namespace PowerSourceConfiguration {

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::Sources::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, sources);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace PowerSourceConfiguration
namespace PowerSource {
namespace Structs {

namespace BatChargeFaultChangeType {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kCurrent), current);
    encoder.Encode(to_underlying(Fields::kPrevious), previous);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCurrent))
        {
            err = DataModel::Decode(reader, current);
        }
        else if (__context_tag == to_underlying(Fields::kPrevious))
        {
            err = DataModel::Decode(reader, previous);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace BatChargeFaultChangeType

namespace BatFaultChangeType {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kCurrent), current);
    encoder.Encode(to_underlying(Fields::kPrevious), previous);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCurrent))
        {
            err = DataModel::Decode(reader, current);
        }
        else if (__context_tag == to_underlying(Fields::kPrevious))
        {
            err = DataModel::Decode(reader, previous);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace BatFaultChangeType

namespace WiredFaultChangeType {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kCurrent), current);
    encoder.Encode(to_underlying(Fields::kPrevious), previous);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCurrent))
        {
            err = DataModel::Decode(reader, current);
        }
        else if (__context_tag == to_underlying(Fields::kPrevious))
        {
            err = DataModel::Decode(reader, previous);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace WiredFaultChangeType
} // namespace Structs

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::Status::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, status);
    case Attributes::Order::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, order);
    case Attributes::Description::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, description);
    case Attributes::WiredAssessedInputVoltage::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, wiredAssessedInputVoltage);
    case Attributes::WiredAssessedInputFrequency::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, wiredAssessedInputFrequency);
    case Attributes::WiredCurrentType::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, wiredCurrentType);
    case Attributes::WiredAssessedCurrent::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, wiredAssessedCurrent);
    case Attributes::WiredNominalVoltage::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, wiredNominalVoltage);
    case Attributes::WiredMaximumCurrent::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, wiredMaximumCurrent);
    case Attributes::WiredPresent::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, wiredPresent);
    case Attributes::ActiveWiredFaults::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, activeWiredFaults);
    case Attributes::BatVoltage::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, batVoltage);
    case Attributes::BatPercentRemaining::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, batPercentRemaining);
    case Attributes::BatTimeRemaining::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, batTimeRemaining);
    case Attributes::BatChargeLevel::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, batChargeLevel);
    case Attributes::BatReplacementNeeded::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, batReplacementNeeded);
    case Attributes::BatReplaceability::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, batReplaceability);
    case Attributes::BatPresent::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, batPresent);
    case Attributes::ActiveBatFaults::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, activeBatFaults);
    case Attributes::BatReplacementDescription::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, batReplacementDescription);
    case Attributes::BatCommonDesignation::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, batCommonDesignation);
    case Attributes::BatANSIDesignation::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, batANSIDesignation);
    case Attributes::BatIECDesignation::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, batIECDesignation);
    case Attributes::BatApprovedChemistry::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, batApprovedChemistry);
    case Attributes::BatCapacity::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, batCapacity);
    case Attributes::BatQuantity::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, batQuantity);
    case Attributes::BatChargeState::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, batChargeState);
    case Attributes::BatTimeToFullCharge::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, batTimeToFullCharge);
    case Attributes::BatFunctionalWhileCharging::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, batFunctionalWhileCharging);
    case Attributes::BatChargingCurrent::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, batChargingCurrent);
    case Attributes::ActiveBatChargeFaults::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, activeBatChargeFaults);
    case Attributes::EndpointList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, endpointList);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace WiredFaultChange {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrent), current));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPrevious), previous));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCurrent))
        {
            err = DataModel::Decode(reader, current);
        }
        else if (__context_tag == to_underlying(Fields::kPrevious))
        {
            err = DataModel::Decode(reader, previous);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace WiredFaultChange.
namespace BatFaultChange {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrent), current));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPrevious), previous));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCurrent))
        {
            err = DataModel::Decode(reader, current);
        }
        else if (__context_tag == to_underlying(Fields::kPrevious))
        {
            err = DataModel::Decode(reader, previous);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace BatFaultChange.
namespace BatChargeFaultChange {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrent), current));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPrevious), previous));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCurrent))
        {
            err = DataModel::Decode(reader, current);
        }
        else if (__context_tag == to_underlying(Fields::kPrevious))
        {
            err = DataModel::Decode(reader, previous);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace BatChargeFaultChange.
} // namespace Events

} // namespace PowerSource
namespace GeneralCommissioning {
namespace Structs {

namespace BasicCommissioningInfo {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kFailSafeExpiryLengthSeconds), failSafeExpiryLengthSeconds);
    encoder.Encode(to_underlying(Fields::kMaxCumulativeFailsafeSeconds), maxCumulativeFailsafeSeconds);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kFailSafeExpiryLengthSeconds))
        {
            err = DataModel::Decode(reader, failSafeExpiryLengthSeconds);
        }
        else if (__context_tag == to_underlying(Fields::kMaxCumulativeFailsafeSeconds))
        {
            err = DataModel::Decode(reader, maxCumulativeFailsafeSeconds);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace BasicCommissioningInfo
} // namespace Structs

namespace Commands {
namespace ArmFailSafe {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kExpiryLengthSeconds), expiryLengthSeconds);
    encoder.Encode(to_underlying(Fields::kBreadcrumb), breadcrumb);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kExpiryLengthSeconds))
        {
            err = DataModel::Decode(reader, expiryLengthSeconds);
        }
        else if (__context_tag == to_underlying(Fields::kBreadcrumb))
        {
            err = DataModel::Decode(reader, breadcrumb);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ArmFailSafe.
namespace ArmFailSafeResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kErrorCode), errorCode);
    encoder.Encode(to_underlying(Fields::kDebugText), debugText);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kErrorCode))
        {
            err = DataModel::Decode(reader, errorCode);
        }
        else if (__context_tag == to_underlying(Fields::kDebugText))
        {
            err = DataModel::Decode(reader, debugText);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ArmFailSafeResponse.
namespace SetRegulatoryConfig {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kNewRegulatoryConfig), newRegulatoryConfig);
    encoder.Encode(to_underlying(Fields::kCountryCode), countryCode);
    encoder.Encode(to_underlying(Fields::kBreadcrumb), breadcrumb);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNewRegulatoryConfig))
        {
            err = DataModel::Decode(reader, newRegulatoryConfig);
        }
        else if (__context_tag == to_underlying(Fields::kCountryCode))
        {
            err = DataModel::Decode(reader, countryCode);
        }
        else if (__context_tag == to_underlying(Fields::kBreadcrumb))
        {
            err = DataModel::Decode(reader, breadcrumb);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetRegulatoryConfig.
namespace SetRegulatoryConfigResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kErrorCode), errorCode);
    encoder.Encode(to_underlying(Fields::kDebugText), debugText);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kErrorCode))
        {
            err = DataModel::Decode(reader, errorCode);
        }
        else if (__context_tag == to_underlying(Fields::kDebugText))
        {
            err = DataModel::Decode(reader, debugText);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetRegulatoryConfigResponse.
namespace CommissioningComplete {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace CommissioningComplete.
namespace CommissioningCompleteResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kErrorCode), errorCode);
    encoder.Encode(to_underlying(Fields::kDebugText), debugText);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kErrorCode))
        {
            err = DataModel::Decode(reader, errorCode);
        }
        else if (__context_tag == to_underlying(Fields::kDebugText))
        {
            err = DataModel::Decode(reader, debugText);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace CommissioningCompleteResponse.
namespace SetTCAcknowledgements {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kTCVersion), TCVersion);
    encoder.Encode(to_underlying(Fields::kTCUserResponse), TCUserResponse);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kTCVersion))
        {
            err = DataModel::Decode(reader, TCVersion);
        }
        else if (__context_tag == to_underlying(Fields::kTCUserResponse))
        {
            err = DataModel::Decode(reader, TCUserResponse);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetTCAcknowledgements.
namespace SetTCAcknowledgementsResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kErrorCode), errorCode);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kErrorCode))
        {
            err = DataModel::Decode(reader, errorCode);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetTCAcknowledgementsResponse.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::Breadcrumb::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, breadcrumb);
    case Attributes::BasicCommissioningInfo::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, basicCommissioningInfo);
    case Attributes::RegulatoryConfig::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, regulatoryConfig);
    case Attributes::LocationCapability::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, locationCapability);
    case Attributes::SupportsConcurrentConnection::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, supportsConcurrentConnection);
    case Attributes::TCAcceptedVersion::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, TCAcceptedVersion);
    case Attributes::TCMinRequiredVersion::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, TCMinRequiredVersion);
    case Attributes::TCAcknowledgements::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, TCAcknowledgements);
    case Attributes::TCAcknowledgementsRequired::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, TCAcknowledgementsRequired);
    case Attributes::TCUpdateDeadline::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, TCUpdateDeadline);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace GeneralCommissioning
namespace NetworkCommissioning {
namespace Structs {

namespace NetworkInfoStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kNetworkID), networkID);
    encoder.Encode(to_underlying(Fields::kConnected), connected);
    encoder.Encode(to_underlying(Fields::kNetworkIdentifier), networkIdentifier);
    encoder.Encode(to_underlying(Fields::kClientIdentifier), clientIdentifier);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNetworkID))
        {
            err = DataModel::Decode(reader, networkID);
        }
        else if (__context_tag == to_underlying(Fields::kConnected))
        {
            err = DataModel::Decode(reader, connected);
        }
        else if (__context_tag == to_underlying(Fields::kNetworkIdentifier))
        {
            err = DataModel::Decode(reader, networkIdentifier);
        }
        else if (__context_tag == to_underlying(Fields::kClientIdentifier))
        {
            err = DataModel::Decode(reader, clientIdentifier);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace NetworkInfoStruct

namespace ThreadInterfaceScanResultStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kPanId), panId);
    encoder.Encode(to_underlying(Fields::kExtendedPanId), extendedPanId);
    encoder.Encode(to_underlying(Fields::kNetworkName), networkName);
    encoder.Encode(to_underlying(Fields::kChannel), channel);
    encoder.Encode(to_underlying(Fields::kVersion), version);
    encoder.Encode(to_underlying(Fields::kExtendedAddress), extendedAddress);
    encoder.Encode(to_underlying(Fields::kRssi), rssi);
    encoder.Encode(to_underlying(Fields::kLqi), lqi);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kPanId))
        {
            err = DataModel::Decode(reader, panId);
        }
        else if (__context_tag == to_underlying(Fields::kExtendedPanId))
        {
            err = DataModel::Decode(reader, extendedPanId);
        }
        else if (__context_tag == to_underlying(Fields::kNetworkName))
        {
            err = DataModel::Decode(reader, networkName);
        }
        else if (__context_tag == to_underlying(Fields::kChannel))
        {
            err = DataModel::Decode(reader, channel);
        }
        else if (__context_tag == to_underlying(Fields::kVersion))
        {
            err = DataModel::Decode(reader, version);
        }
        else if (__context_tag == to_underlying(Fields::kExtendedAddress))
        {
            err = DataModel::Decode(reader, extendedAddress);
        }
        else if (__context_tag == to_underlying(Fields::kRssi))
        {
            err = DataModel::Decode(reader, rssi);
        }
        else if (__context_tag == to_underlying(Fields::kLqi))
        {
            err = DataModel::Decode(reader, lqi);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ThreadInterfaceScanResultStruct

namespace WiFiInterfaceScanResultStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kSecurity), security);
    encoder.Encode(to_underlying(Fields::kSsid), ssid);
    encoder.Encode(to_underlying(Fields::kBssid), bssid);
    encoder.Encode(to_underlying(Fields::kChannel), channel);
    encoder.Encode(to_underlying(Fields::kWiFiBand), wiFiBand);
    encoder.Encode(to_underlying(Fields::kRssi), rssi);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kSecurity))
        {
            err = DataModel::Decode(reader, security);
        }
        else if (__context_tag == to_underlying(Fields::kSsid))
        {
            err = DataModel::Decode(reader, ssid);
        }
        else if (__context_tag == to_underlying(Fields::kBssid))
        {
            err = DataModel::Decode(reader, bssid);
        }
        else if (__context_tag == to_underlying(Fields::kChannel))
        {
            err = DataModel::Decode(reader, channel);
        }
        else if (__context_tag == to_underlying(Fields::kWiFiBand))
        {
            err = DataModel::Decode(reader, wiFiBand);
        }
        else if (__context_tag == to_underlying(Fields::kRssi))
        {
            err = DataModel::Decode(reader, rssi);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace WiFiInterfaceScanResultStruct
} // namespace Structs

namespace Commands {
namespace ScanNetworks {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kSsid), ssid);
    encoder.Encode(to_underlying(Fields::kBreadcrumb), breadcrumb);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kSsid))
        {
            err = DataModel::Decode(reader, ssid);
        }
        else if (__context_tag == to_underlying(Fields::kBreadcrumb))
        {
            err = DataModel::Decode(reader, breadcrumb);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ScanNetworks.
namespace ScanNetworksResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kNetworkingStatus), networkingStatus);
    encoder.Encode(to_underlying(Fields::kDebugText), debugText);
    encoder.Encode(to_underlying(Fields::kWiFiScanResults), wiFiScanResults);
    encoder.Encode(to_underlying(Fields::kThreadScanResults), threadScanResults);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNetworkingStatus))
        {
            err = DataModel::Decode(reader, networkingStatus);
        }
        else if (__context_tag == to_underlying(Fields::kDebugText))
        {
            err = DataModel::Decode(reader, debugText);
        }
        else if (__context_tag == to_underlying(Fields::kWiFiScanResults))
        {
            err = DataModel::Decode(reader, wiFiScanResults);
        }
        else if (__context_tag == to_underlying(Fields::kThreadScanResults))
        {
            err = DataModel::Decode(reader, threadScanResults);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ScanNetworksResponse.
namespace AddOrUpdateWiFiNetwork {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kSsid), ssid);
    encoder.Encode(to_underlying(Fields::kCredentials), credentials);
    encoder.Encode(to_underlying(Fields::kBreadcrumb), breadcrumb);
    encoder.Encode(to_underlying(Fields::kNetworkIdentity), networkIdentity);
    encoder.Encode(to_underlying(Fields::kClientIdentifier), clientIdentifier);
    encoder.Encode(to_underlying(Fields::kPossessionNonce), possessionNonce);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kSsid))
        {
            err = DataModel::Decode(reader, ssid);
        }
        else if (__context_tag == to_underlying(Fields::kCredentials))
        {
            err = DataModel::Decode(reader, credentials);
        }
        else if (__context_tag == to_underlying(Fields::kBreadcrumb))
        {
            err = DataModel::Decode(reader, breadcrumb);
        }
        else if (__context_tag == to_underlying(Fields::kNetworkIdentity))
        {
            err = DataModel::Decode(reader, networkIdentity);
        }
        else if (__context_tag == to_underlying(Fields::kClientIdentifier))
        {
            err = DataModel::Decode(reader, clientIdentifier);
        }
        else if (__context_tag == to_underlying(Fields::kPossessionNonce))
        {
            err = DataModel::Decode(reader, possessionNonce);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace AddOrUpdateWiFiNetwork.
namespace AddOrUpdateThreadNetwork {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kOperationalDataset), operationalDataset);
    encoder.Encode(to_underlying(Fields::kBreadcrumb), breadcrumb);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kOperationalDataset))
        {
            err = DataModel::Decode(reader, operationalDataset);
        }
        else if (__context_tag == to_underlying(Fields::kBreadcrumb))
        {
            err = DataModel::Decode(reader, breadcrumb);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace AddOrUpdateThreadNetwork.
namespace RemoveNetwork {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kNetworkID), networkID);
    encoder.Encode(to_underlying(Fields::kBreadcrumb), breadcrumb);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNetworkID))
        {
            err = DataModel::Decode(reader, networkID);
        }
        else if (__context_tag == to_underlying(Fields::kBreadcrumb))
        {
            err = DataModel::Decode(reader, breadcrumb);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace RemoveNetwork.
namespace NetworkConfigResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kNetworkingStatus), networkingStatus);
    encoder.Encode(to_underlying(Fields::kDebugText), debugText);
    encoder.Encode(to_underlying(Fields::kNetworkIndex), networkIndex);
    encoder.Encode(to_underlying(Fields::kClientIdentity), clientIdentity);
    encoder.Encode(to_underlying(Fields::kPossessionSignature), possessionSignature);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNetworkingStatus))
        {
            err = DataModel::Decode(reader, networkingStatus);
        }
        else if (__context_tag == to_underlying(Fields::kDebugText))
        {
            err = DataModel::Decode(reader, debugText);
        }
        else if (__context_tag == to_underlying(Fields::kNetworkIndex))
        {
            err = DataModel::Decode(reader, networkIndex);
        }
        else if (__context_tag == to_underlying(Fields::kClientIdentity))
        {
            err = DataModel::Decode(reader, clientIdentity);
        }
        else if (__context_tag == to_underlying(Fields::kPossessionSignature))
        {
            err = DataModel::Decode(reader, possessionSignature);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace NetworkConfigResponse.
namespace ConnectNetwork {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kNetworkID), networkID);
    encoder.Encode(to_underlying(Fields::kBreadcrumb), breadcrumb);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNetworkID))
        {
            err = DataModel::Decode(reader, networkID);
        }
        else if (__context_tag == to_underlying(Fields::kBreadcrumb))
        {
            err = DataModel::Decode(reader, breadcrumb);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ConnectNetwork.
namespace ConnectNetworkResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kNetworkingStatus), networkingStatus);
    encoder.Encode(to_underlying(Fields::kDebugText), debugText);
    encoder.Encode(to_underlying(Fields::kErrorValue), errorValue);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNetworkingStatus))
        {
            err = DataModel::Decode(reader, networkingStatus);
        }
        else if (__context_tag == to_underlying(Fields::kDebugText))
        {
            err = DataModel::Decode(reader, debugText);
        }
        else if (__context_tag == to_underlying(Fields::kErrorValue))
        {
            err = DataModel::Decode(reader, errorValue);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ConnectNetworkResponse.
namespace ReorderNetwork {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kNetworkID), networkID);
    encoder.Encode(to_underlying(Fields::kNetworkIndex), networkIndex);
    encoder.Encode(to_underlying(Fields::kBreadcrumb), breadcrumb);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNetworkID))
        {
            err = DataModel::Decode(reader, networkID);
        }
        else if (__context_tag == to_underlying(Fields::kNetworkIndex))
        {
            err = DataModel::Decode(reader, networkIndex);
        }
        else if (__context_tag == to_underlying(Fields::kBreadcrumb))
        {
            err = DataModel::Decode(reader, breadcrumb);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ReorderNetwork.
namespace QueryIdentity {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kKeyIdentifier), keyIdentifier);
    encoder.Encode(to_underlying(Fields::kPossessionNonce), possessionNonce);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kKeyIdentifier))
        {
            err = DataModel::Decode(reader, keyIdentifier);
        }
        else if (__context_tag == to_underlying(Fields::kPossessionNonce))
        {
            err = DataModel::Decode(reader, possessionNonce);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace QueryIdentity.
namespace QueryIdentityResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kIdentity), identity);
    encoder.Encode(to_underlying(Fields::kPossessionSignature), possessionSignature);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kIdentity))
        {
            err = DataModel::Decode(reader, identity);
        }
        else if (__context_tag == to_underlying(Fields::kPossessionSignature))
        {
            err = DataModel::Decode(reader, possessionSignature);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace QueryIdentityResponse.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::MaxNetworks::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxNetworks);
    case Attributes::Networks::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, networks);
    case Attributes::ScanMaxTimeSeconds::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, scanMaxTimeSeconds);
    case Attributes::ConnectMaxTimeSeconds::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, connectMaxTimeSeconds);
    case Attributes::InterfaceEnabled::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, interfaceEnabled);
    case Attributes::LastNetworkingStatus::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, lastNetworkingStatus);
    case Attributes::LastNetworkID::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, lastNetworkID);
    case Attributes::LastConnectErrorValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, lastConnectErrorValue);
    case Attributes::SupportedWiFiBands::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, supportedWiFiBands);
    case Attributes::SupportedThreadFeatures::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, supportedThreadFeatures);
    case Attributes::ThreadVersion::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, threadVersion);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace NetworkCommissioning
namespace DiagnosticLogs {

namespace Commands {
namespace RetrieveLogsRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kIntent), intent);
    encoder.Encode(to_underlying(Fields::kRequestedProtocol), requestedProtocol);
    encoder.Encode(to_underlying(Fields::kTransferFileDesignator), transferFileDesignator);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kIntent))
        {
            err = DataModel::Decode(reader, intent);
        }
        else if (__context_tag == to_underlying(Fields::kRequestedProtocol))
        {
            err = DataModel::Decode(reader, requestedProtocol);
        }
        else if (__context_tag == to_underlying(Fields::kTransferFileDesignator))
        {
            err = DataModel::Decode(reader, transferFileDesignator);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace RetrieveLogsRequest.
namespace RetrieveLogsResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kLogContent), logContent);
    encoder.Encode(to_underlying(Fields::kUTCTimeStamp), UTCTimeStamp);
    encoder.Encode(to_underlying(Fields::kTimeSinceBoot), timeSinceBoot);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kLogContent))
        {
            err = DataModel::Decode(reader, logContent);
        }
        else if (__context_tag == to_underlying(Fields::kUTCTimeStamp))
        {
            err = DataModel::Decode(reader, UTCTimeStamp);
        }
        else if (__context_tag == to_underlying(Fields::kTimeSinceBoot))
        {
            err = DataModel::Decode(reader, timeSinceBoot);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace RetrieveLogsResponse.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace DiagnosticLogs
namespace GeneralDiagnostics {
namespace Structs {

namespace NetworkInterface {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kName), name);
    encoder.Encode(to_underlying(Fields::kIsOperational), isOperational);
    encoder.Encode(to_underlying(Fields::kOffPremiseServicesReachableIPv4), offPremiseServicesReachableIPv4);
    encoder.Encode(to_underlying(Fields::kOffPremiseServicesReachableIPv6), offPremiseServicesReachableIPv6);
    encoder.Encode(to_underlying(Fields::kHardwareAddress), hardwareAddress);
    encoder.Encode(to_underlying(Fields::kIPv4Addresses), IPv4Addresses);
    encoder.Encode(to_underlying(Fields::kIPv6Addresses), IPv6Addresses);
    encoder.Encode(to_underlying(Fields::kType), type);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kName))
        {
            err = DataModel::Decode(reader, name);
        }
        else if (__context_tag == to_underlying(Fields::kIsOperational))
        {
            err = DataModel::Decode(reader, isOperational);
        }
        else if (__context_tag == to_underlying(Fields::kOffPremiseServicesReachableIPv4))
        {
            err = DataModel::Decode(reader, offPremiseServicesReachableIPv4);
        }
        else if (__context_tag == to_underlying(Fields::kOffPremiseServicesReachableIPv6))
        {
            err = DataModel::Decode(reader, offPremiseServicesReachableIPv6);
        }
        else if (__context_tag == to_underlying(Fields::kHardwareAddress))
        {
            err = DataModel::Decode(reader, hardwareAddress);
        }
        else if (__context_tag == to_underlying(Fields::kIPv4Addresses))
        {
            err = DataModel::Decode(reader, IPv4Addresses);
        }
        else if (__context_tag == to_underlying(Fields::kIPv6Addresses))
        {
            err = DataModel::Decode(reader, IPv6Addresses);
        }
        else if (__context_tag == to_underlying(Fields::kType))
        {
            err = DataModel::Decode(reader, type);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace NetworkInterface
} // namespace Structs

namespace Commands {
namespace TestEventTrigger {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kEnableKey), enableKey);
    encoder.Encode(to_underlying(Fields::kEventTrigger), eventTrigger);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kEnableKey))
        {
            err = DataModel::Decode(reader, enableKey);
        }
        else if (__context_tag == to_underlying(Fields::kEventTrigger))
        {
            err = DataModel::Decode(reader, eventTrigger);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestEventTrigger.
namespace TimeSnapshot {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace TimeSnapshot.
namespace TimeSnapshotResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kSystemTimeMs), systemTimeMs);
    encoder.Encode(to_underlying(Fields::kPosixTimeMs), posixTimeMs);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kSystemTimeMs))
        {
            err = DataModel::Decode(reader, systemTimeMs);
        }
        else if (__context_tag == to_underlying(Fields::kPosixTimeMs))
        {
            err = DataModel::Decode(reader, posixTimeMs);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TimeSnapshotResponse.
namespace PayloadTestRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kEnableKey), enableKey);
    encoder.Encode(to_underlying(Fields::kValue), value);
    encoder.Encode(to_underlying(Fields::kCount), count);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kEnableKey))
        {
            err = DataModel::Decode(reader, enableKey);
        }
        else if (__context_tag == to_underlying(Fields::kValue))
        {
            err = DataModel::Decode(reader, value);
        }
        else if (__context_tag == to_underlying(Fields::kCount))
        {
            err = DataModel::Decode(reader, count);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace PayloadTestRequest.
namespace PayloadTestResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kPayload), payload);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kPayload))
        {
            err = DataModel::Decode(reader, payload);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace PayloadTestResponse.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::NetworkInterfaces::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, networkInterfaces);
    case Attributes::RebootCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, rebootCount);
    case Attributes::UpTime::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, upTime);
    case Attributes::TotalOperationalHours::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, totalOperationalHours);
    case Attributes::BootReason::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, bootReason);
    case Attributes::ActiveHardwareFaults::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, activeHardwareFaults);
    case Attributes::ActiveRadioFaults::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, activeRadioFaults);
    case Attributes::ActiveNetworkFaults::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, activeNetworkFaults);
    case Attributes::TestEventTriggersEnabled::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, testEventTriggersEnabled);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace HardwareFaultChange {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrent), current));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPrevious), previous));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCurrent))
        {
            err = DataModel::Decode(reader, current);
        }
        else if (__context_tag == to_underlying(Fields::kPrevious))
        {
            err = DataModel::Decode(reader, previous);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace HardwareFaultChange.
namespace RadioFaultChange {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrent), current));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPrevious), previous));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCurrent))
        {
            err = DataModel::Decode(reader, current);
        }
        else if (__context_tag == to_underlying(Fields::kPrevious))
        {
            err = DataModel::Decode(reader, previous);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace RadioFaultChange.
namespace NetworkFaultChange {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrent), current));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPrevious), previous));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCurrent))
        {
            err = DataModel::Decode(reader, current);
        }
        else if (__context_tag == to_underlying(Fields::kPrevious))
        {
            err = DataModel::Decode(reader, previous);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace NetworkFaultChange.
namespace BootReason {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kBootReason), bootReason));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kBootReason))
        {
            err = DataModel::Decode(reader, bootReason);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace BootReason.
} // namespace Events

} // namespace GeneralDiagnostics
namespace SoftwareDiagnostics {
namespace Structs {

namespace ThreadMetricsStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kId), id);
    encoder.Encode(to_underlying(Fields::kName), name);
    encoder.Encode(to_underlying(Fields::kStackFreeCurrent), stackFreeCurrent);
    encoder.Encode(to_underlying(Fields::kStackFreeMinimum), stackFreeMinimum);
    encoder.Encode(to_underlying(Fields::kStackSize), stackSize);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kId))
        {
            err = DataModel::Decode(reader, id);
        }
        else if (__context_tag == to_underlying(Fields::kName))
        {
            err = DataModel::Decode(reader, name);
        }
        else if (__context_tag == to_underlying(Fields::kStackFreeCurrent))
        {
            err = DataModel::Decode(reader, stackFreeCurrent);
        }
        else if (__context_tag == to_underlying(Fields::kStackFreeMinimum))
        {
            err = DataModel::Decode(reader, stackFreeMinimum);
        }
        else if (__context_tag == to_underlying(Fields::kStackSize))
        {
            err = DataModel::Decode(reader, stackSize);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ThreadMetricsStruct
} // namespace Structs

namespace Commands {
namespace ResetWatermarks {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace ResetWatermarks.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::ThreadMetrics::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, threadMetrics);
    case Attributes::CurrentHeapFree::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentHeapFree);
    case Attributes::CurrentHeapUsed::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentHeapUsed);
    case Attributes::CurrentHeapHighWatermark::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentHeapHighWatermark);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace SoftwareFault {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kId), id));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kName), name));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kFaultRecording), faultRecording));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kId))
        {
            err = DataModel::Decode(reader, id);
        }
        else if (__context_tag == to_underlying(Fields::kName))
        {
            err = DataModel::Decode(reader, name);
        }
        else if (__context_tag == to_underlying(Fields::kFaultRecording))
        {
            err = DataModel::Decode(reader, faultRecording);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SoftwareFault.
} // namespace Events

} // namespace SoftwareDiagnostics
namespace ThreadNetworkDiagnostics {
namespace Structs {

namespace NeighborTableStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kExtAddress), extAddress);
    encoder.Encode(to_underlying(Fields::kAge), age);
    encoder.Encode(to_underlying(Fields::kRloc16), rloc16);
    encoder.Encode(to_underlying(Fields::kLinkFrameCounter), linkFrameCounter);
    encoder.Encode(to_underlying(Fields::kMleFrameCounter), mleFrameCounter);
    encoder.Encode(to_underlying(Fields::kLqi), lqi);
    encoder.Encode(to_underlying(Fields::kAverageRssi), averageRssi);
    encoder.Encode(to_underlying(Fields::kLastRssi), lastRssi);
    encoder.Encode(to_underlying(Fields::kFrameErrorRate), frameErrorRate);
    encoder.Encode(to_underlying(Fields::kMessageErrorRate), messageErrorRate);
    encoder.Encode(to_underlying(Fields::kRxOnWhenIdle), rxOnWhenIdle);
    encoder.Encode(to_underlying(Fields::kFullThreadDevice), fullThreadDevice);
    encoder.Encode(to_underlying(Fields::kFullNetworkData), fullNetworkData);
    encoder.Encode(to_underlying(Fields::kIsChild), isChild);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kExtAddress))
        {
            err = DataModel::Decode(reader, extAddress);
        }
        else if (__context_tag == to_underlying(Fields::kAge))
        {
            err = DataModel::Decode(reader, age);
        }
        else if (__context_tag == to_underlying(Fields::kRloc16))
        {
            err = DataModel::Decode(reader, rloc16);
        }
        else if (__context_tag == to_underlying(Fields::kLinkFrameCounter))
        {
            err = DataModel::Decode(reader, linkFrameCounter);
        }
        else if (__context_tag == to_underlying(Fields::kMleFrameCounter))
        {
            err = DataModel::Decode(reader, mleFrameCounter);
        }
        else if (__context_tag == to_underlying(Fields::kLqi))
        {
            err = DataModel::Decode(reader, lqi);
        }
        else if (__context_tag == to_underlying(Fields::kAverageRssi))
        {
            err = DataModel::Decode(reader, averageRssi);
        }
        else if (__context_tag == to_underlying(Fields::kLastRssi))
        {
            err = DataModel::Decode(reader, lastRssi);
        }
        else if (__context_tag == to_underlying(Fields::kFrameErrorRate))
        {
            err = DataModel::Decode(reader, frameErrorRate);
        }
        else if (__context_tag == to_underlying(Fields::kMessageErrorRate))
        {
            err = DataModel::Decode(reader, messageErrorRate);
        }
        else if (__context_tag == to_underlying(Fields::kRxOnWhenIdle))
        {
            err = DataModel::Decode(reader, rxOnWhenIdle);
        }
        else if (__context_tag == to_underlying(Fields::kFullThreadDevice))
        {
            err = DataModel::Decode(reader, fullThreadDevice);
        }
        else if (__context_tag == to_underlying(Fields::kFullNetworkData))
        {
            err = DataModel::Decode(reader, fullNetworkData);
        }
        else if (__context_tag == to_underlying(Fields::kIsChild))
        {
            err = DataModel::Decode(reader, isChild);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace NeighborTableStruct

namespace OperationalDatasetComponents {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kActiveTimestampPresent), activeTimestampPresent);
    encoder.Encode(to_underlying(Fields::kPendingTimestampPresent), pendingTimestampPresent);
    encoder.Encode(to_underlying(Fields::kMasterKeyPresent), masterKeyPresent);
    encoder.Encode(to_underlying(Fields::kNetworkNamePresent), networkNamePresent);
    encoder.Encode(to_underlying(Fields::kExtendedPanIdPresent), extendedPanIdPresent);
    encoder.Encode(to_underlying(Fields::kMeshLocalPrefixPresent), meshLocalPrefixPresent);
    encoder.Encode(to_underlying(Fields::kDelayPresent), delayPresent);
    encoder.Encode(to_underlying(Fields::kPanIdPresent), panIdPresent);
    encoder.Encode(to_underlying(Fields::kChannelPresent), channelPresent);
    encoder.Encode(to_underlying(Fields::kPskcPresent), pskcPresent);
    encoder.Encode(to_underlying(Fields::kSecurityPolicyPresent), securityPolicyPresent);
    encoder.Encode(to_underlying(Fields::kChannelMaskPresent), channelMaskPresent);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kActiveTimestampPresent))
        {
            err = DataModel::Decode(reader, activeTimestampPresent);
        }
        else if (__context_tag == to_underlying(Fields::kPendingTimestampPresent))
        {
            err = DataModel::Decode(reader, pendingTimestampPresent);
        }
        else if (__context_tag == to_underlying(Fields::kMasterKeyPresent))
        {
            err = DataModel::Decode(reader, masterKeyPresent);
        }
        else if (__context_tag == to_underlying(Fields::kNetworkNamePresent))
        {
            err = DataModel::Decode(reader, networkNamePresent);
        }
        else if (__context_tag == to_underlying(Fields::kExtendedPanIdPresent))
        {
            err = DataModel::Decode(reader, extendedPanIdPresent);
        }
        else if (__context_tag == to_underlying(Fields::kMeshLocalPrefixPresent))
        {
            err = DataModel::Decode(reader, meshLocalPrefixPresent);
        }
        else if (__context_tag == to_underlying(Fields::kDelayPresent))
        {
            err = DataModel::Decode(reader, delayPresent);
        }
        else if (__context_tag == to_underlying(Fields::kPanIdPresent))
        {
            err = DataModel::Decode(reader, panIdPresent);
        }
        else if (__context_tag == to_underlying(Fields::kChannelPresent))
        {
            err = DataModel::Decode(reader, channelPresent);
        }
        else if (__context_tag == to_underlying(Fields::kPskcPresent))
        {
            err = DataModel::Decode(reader, pskcPresent);
        }
        else if (__context_tag == to_underlying(Fields::kSecurityPolicyPresent))
        {
            err = DataModel::Decode(reader, securityPolicyPresent);
        }
        else if (__context_tag == to_underlying(Fields::kChannelMaskPresent))
        {
            err = DataModel::Decode(reader, channelMaskPresent);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace OperationalDatasetComponents

namespace RouteTableStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kExtAddress), extAddress);
    encoder.Encode(to_underlying(Fields::kRloc16), rloc16);
    encoder.Encode(to_underlying(Fields::kRouterId), routerId);
    encoder.Encode(to_underlying(Fields::kNextHop), nextHop);
    encoder.Encode(to_underlying(Fields::kPathCost), pathCost);
    encoder.Encode(to_underlying(Fields::kLQIIn), LQIIn);
    encoder.Encode(to_underlying(Fields::kLQIOut), LQIOut);
    encoder.Encode(to_underlying(Fields::kAge), age);
    encoder.Encode(to_underlying(Fields::kAllocated), allocated);
    encoder.Encode(to_underlying(Fields::kLinkEstablished), linkEstablished);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kExtAddress))
        {
            err = DataModel::Decode(reader, extAddress);
        }
        else if (__context_tag == to_underlying(Fields::kRloc16))
        {
            err = DataModel::Decode(reader, rloc16);
        }
        else if (__context_tag == to_underlying(Fields::kRouterId))
        {
            err = DataModel::Decode(reader, routerId);
        }
        else if (__context_tag == to_underlying(Fields::kNextHop))
        {
            err = DataModel::Decode(reader, nextHop);
        }
        else if (__context_tag == to_underlying(Fields::kPathCost))
        {
            err = DataModel::Decode(reader, pathCost);
        }
        else if (__context_tag == to_underlying(Fields::kLQIIn))
        {
            err = DataModel::Decode(reader, LQIIn);
        }
        else if (__context_tag == to_underlying(Fields::kLQIOut))
        {
            err = DataModel::Decode(reader, LQIOut);
        }
        else if (__context_tag == to_underlying(Fields::kAge))
        {
            err = DataModel::Decode(reader, age);
        }
        else if (__context_tag == to_underlying(Fields::kAllocated))
        {
            err = DataModel::Decode(reader, allocated);
        }
        else if (__context_tag == to_underlying(Fields::kLinkEstablished))
        {
            err = DataModel::Decode(reader, linkEstablished);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace RouteTableStruct

namespace SecurityPolicy {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kRotationTime), rotationTime);
    encoder.Encode(to_underlying(Fields::kFlags), flags);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kRotationTime))
        {
            err = DataModel::Decode(reader, rotationTime);
        }
        else if (__context_tag == to_underlying(Fields::kFlags))
        {
            err = DataModel::Decode(reader, flags);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace SecurityPolicy
} // namespace Structs

namespace Commands {
namespace ResetCounts {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace ResetCounts.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::Channel::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, channel);
    case Attributes::RoutingRole::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, routingRole);
    case Attributes::NetworkName::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, networkName);
    case Attributes::PanId::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, panId);
    case Attributes::ExtendedPanId::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, extendedPanId);
    case Attributes::MeshLocalPrefix::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, meshLocalPrefix);
    case Attributes::OverrunCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, overrunCount);
    case Attributes::NeighborTable::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, neighborTable);
    case Attributes::RouteTable::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, routeTable);
    case Attributes::PartitionId::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, partitionId);
    case Attributes::Weighting::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, weighting);
    case Attributes::DataVersion::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, dataVersion);
    case Attributes::StableDataVersion::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, stableDataVersion);
    case Attributes::LeaderRouterId::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, leaderRouterId);
    case Attributes::DetachedRoleCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, detachedRoleCount);
    case Attributes::ChildRoleCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, childRoleCount);
    case Attributes::RouterRoleCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, routerRoleCount);
    case Attributes::LeaderRoleCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, leaderRoleCount);
    case Attributes::AttachAttemptCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attachAttemptCount);
    case Attributes::PartitionIdChangeCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, partitionIdChangeCount);
    case Attributes::BetterPartitionAttachAttemptCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, betterPartitionAttachAttemptCount);
    case Attributes::ParentChangeCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, parentChangeCount);
    case Attributes::TxTotalCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, txTotalCount);
    case Attributes::TxUnicastCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, txUnicastCount);
    case Attributes::TxBroadcastCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, txBroadcastCount);
    case Attributes::TxAckRequestedCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, txAckRequestedCount);
    case Attributes::TxAckedCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, txAckedCount);
    case Attributes::TxNoAckRequestedCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, txNoAckRequestedCount);
    case Attributes::TxDataCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, txDataCount);
    case Attributes::TxDataPollCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, txDataPollCount);
    case Attributes::TxBeaconCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, txBeaconCount);
    case Attributes::TxBeaconRequestCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, txBeaconRequestCount);
    case Attributes::TxOtherCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, txOtherCount);
    case Attributes::TxRetryCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, txRetryCount);
    case Attributes::TxDirectMaxRetryExpiryCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, txDirectMaxRetryExpiryCount);
    case Attributes::TxIndirectMaxRetryExpiryCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, txIndirectMaxRetryExpiryCount);
    case Attributes::TxErrCcaCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, txErrCcaCount);
    case Attributes::TxErrAbortCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, txErrAbortCount);
    case Attributes::TxErrBusyChannelCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, txErrBusyChannelCount);
    case Attributes::RxTotalCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, rxTotalCount);
    case Attributes::RxUnicastCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, rxUnicastCount);
    case Attributes::RxBroadcastCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, rxBroadcastCount);
    case Attributes::RxDataCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, rxDataCount);
    case Attributes::RxDataPollCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, rxDataPollCount);
    case Attributes::RxBeaconCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, rxBeaconCount);
    case Attributes::RxBeaconRequestCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, rxBeaconRequestCount);
    case Attributes::RxOtherCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, rxOtherCount);
    case Attributes::RxAddressFilteredCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, rxAddressFilteredCount);
    case Attributes::RxDestAddrFilteredCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, rxDestAddrFilteredCount);
    case Attributes::RxDuplicatedCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, rxDuplicatedCount);
    case Attributes::RxErrNoFrameCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, rxErrNoFrameCount);
    case Attributes::RxErrUnknownNeighborCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, rxErrUnknownNeighborCount);
    case Attributes::RxErrInvalidSrcAddrCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, rxErrInvalidSrcAddrCount);
    case Attributes::RxErrSecCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, rxErrSecCount);
    case Attributes::RxErrFcsCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, rxErrFcsCount);
    case Attributes::RxErrOtherCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, rxErrOtherCount);
    case Attributes::ActiveTimestamp::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, activeTimestamp);
    case Attributes::PendingTimestamp::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, pendingTimestamp);
    case Attributes::Delay::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, delay);
    case Attributes::SecurityPolicy::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, securityPolicy);
    case Attributes::ChannelPage0Mask::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, channelPage0Mask);
    case Attributes::OperationalDatasetComponents::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, operationalDatasetComponents);
    case Attributes::ActiveNetworkFaultsList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, activeNetworkFaultsList);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace ConnectionStatus {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kConnectionStatus), connectionStatus));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kConnectionStatus))
        {
            err = DataModel::Decode(reader, connectionStatus);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ConnectionStatus.
namespace NetworkFaultChange {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrent), current));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPrevious), previous));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCurrent))
        {
            err = DataModel::Decode(reader, current);
        }
        else if (__context_tag == to_underlying(Fields::kPrevious))
        {
            err = DataModel::Decode(reader, previous);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace NetworkFaultChange.
} // namespace Events

} // namespace ThreadNetworkDiagnostics
namespace WiFiNetworkDiagnostics {

namespace Commands {
namespace ResetCounts {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace ResetCounts.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::Bssid::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, bssid);
    case Attributes::SecurityType::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, securityType);
    case Attributes::WiFiVersion::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, wiFiVersion);
    case Attributes::ChannelNumber::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, channelNumber);
    case Attributes::Rssi::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, rssi);
    case Attributes::BeaconLostCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, beaconLostCount);
    case Attributes::BeaconRxCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, beaconRxCount);
    case Attributes::PacketMulticastRxCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, packetMulticastRxCount);
    case Attributes::PacketMulticastTxCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, packetMulticastTxCount);
    case Attributes::PacketUnicastRxCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, packetUnicastRxCount);
    case Attributes::PacketUnicastTxCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, packetUnicastTxCount);
    case Attributes::CurrentMaxRate::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentMaxRate);
    case Attributes::OverrunCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, overrunCount);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace Disconnection {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kReasonCode), reasonCode));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kReasonCode))
        {
            err = DataModel::Decode(reader, reasonCode);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace Disconnection.
namespace AssociationFailure {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAssociationFailureCause), associationFailureCause));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kStatus), status));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kAssociationFailureCause))
        {
            err = DataModel::Decode(reader, associationFailureCause);
        }
        else if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace AssociationFailure.
namespace ConnectionStatus {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kConnectionStatus), connectionStatus));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kConnectionStatus))
        {
            err = DataModel::Decode(reader, connectionStatus);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ConnectionStatus.
} // namespace Events

} // namespace WiFiNetworkDiagnostics
namespace EthernetNetworkDiagnostics {

namespace Commands {
namespace ResetCounts {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace ResetCounts.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::PHYRate::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, PHYRate);
    case Attributes::FullDuplex::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, fullDuplex);
    case Attributes::PacketRxCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, packetRxCount);
    case Attributes::PacketTxCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, packetTxCount);
    case Attributes::TxErrCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, txErrCount);
    case Attributes::CollisionCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, collisionCount);
    case Attributes::OverrunCount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, overrunCount);
    case Attributes::CarrierDetect::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, carrierDetect);
    case Attributes::TimeSinceReset::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, timeSinceReset);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace EthernetNetworkDiagnostics
namespace TimeSynchronization {
namespace Structs {

namespace DSTOffsetStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kOffset), offset);
    encoder.Encode(to_underlying(Fields::kValidStarting), validStarting);
    encoder.Encode(to_underlying(Fields::kValidUntil), validUntil);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kOffset))
        {
            err = DataModel::Decode(reader, offset);
        }
        else if (__context_tag == to_underlying(Fields::kValidStarting))
        {
            err = DataModel::Decode(reader, validStarting);
        }
        else if (__context_tag == to_underlying(Fields::kValidUntil))
        {
            err = DataModel::Decode(reader, validUntil);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace DSTOffsetStruct

namespace FabricScopedTrustedTimeSourceStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kNodeID), nodeID);
    encoder.Encode(to_underlying(Fields::kEndpoint), endpoint);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNodeID))
        {
            err = DataModel::Decode(reader, nodeID);
        }
        else if (__context_tag == to_underlying(Fields::kEndpoint))
        {
            err = DataModel::Decode(reader, endpoint);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace FabricScopedTrustedTimeSourceStruct

namespace TimeZoneStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kOffset), offset);
    encoder.Encode(to_underlying(Fields::kValidAt), validAt);
    encoder.Encode(to_underlying(Fields::kName), name);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kOffset))
        {
            err = DataModel::Decode(reader, offset);
        }
        else if (__context_tag == to_underlying(Fields::kValidAt))
        {
            err = DataModel::Decode(reader, validAt);
        }
        else if (__context_tag == to_underlying(Fields::kName))
        {
            err = DataModel::Decode(reader, name);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace TimeZoneStruct

namespace TrustedTimeSourceStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kFabricIndex), fabricIndex);
    encoder.Encode(to_underlying(Fields::kNodeID), nodeID);
    encoder.Encode(to_underlying(Fields::kEndpoint), endpoint);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kFabricIndex))
        {
            err = DataModel::Decode(reader, fabricIndex);
        }
        else if (__context_tag == to_underlying(Fields::kNodeID))
        {
            err = DataModel::Decode(reader, nodeID);
        }
        else if (__context_tag == to_underlying(Fields::kEndpoint))
        {
            err = DataModel::Decode(reader, endpoint);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace TrustedTimeSourceStruct
} // namespace Structs

namespace Commands {
namespace SetUTCTime {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kUTCTime), UTCTime);
    encoder.Encode(to_underlying(Fields::kGranularity), granularity);
    encoder.Encode(to_underlying(Fields::kTimeSource), timeSource);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kUTCTime))
        {
            err = DataModel::Decode(reader, UTCTime);
        }
        else if (__context_tag == to_underlying(Fields::kGranularity))
        {
            err = DataModel::Decode(reader, granularity);
        }
        else if (__context_tag == to_underlying(Fields::kTimeSource))
        {
            err = DataModel::Decode(reader, timeSource);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetUTCTime.
namespace SetTrustedTimeSource {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kTrustedTimeSource), trustedTimeSource);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kTrustedTimeSource))
        {
            err = DataModel::Decode(reader, trustedTimeSource);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetTrustedTimeSource.
namespace SetTimeZone {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kTimeZone), timeZone);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kTimeZone))
        {
            err = DataModel::Decode(reader, timeZone);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetTimeZone.
namespace SetTimeZoneResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kDSTOffsetRequired), DSTOffsetRequired);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kDSTOffsetRequired))
        {
            err = DataModel::Decode(reader, DSTOffsetRequired);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetTimeZoneResponse.
namespace SetDSTOffset {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kDSTOffset), DSTOffset);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kDSTOffset))
        {
            err = DataModel::Decode(reader, DSTOffset);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetDSTOffset.
namespace SetDefaultNTP {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kDefaultNTP), defaultNTP);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kDefaultNTP))
        {
            err = DataModel::Decode(reader, defaultNTP);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetDefaultNTP.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::UTCTime::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, UTCTime);
    case Attributes::Granularity::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, granularity);
    case Attributes::TimeSource::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, timeSource);
    case Attributes::TrustedTimeSource::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, trustedTimeSource);
    case Attributes::DefaultNTP::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, defaultNTP);
    case Attributes::TimeZone::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, timeZone);
    case Attributes::DSTOffset::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, DSTOffset);
    case Attributes::LocalTime::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, localTime);
    case Attributes::TimeZoneDatabase::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, timeZoneDatabase);
    case Attributes::NTPServerAvailable::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, NTPServerAvailable);
    case Attributes::TimeZoneListMaxSize::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, timeZoneListMaxSize);
    case Attributes::DSTOffsetListMaxSize::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, DSTOffsetListMaxSize);
    case Attributes::SupportsDNSResolve::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, supportsDNSResolve);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace DSTTableEmpty {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace DSTTableEmpty.
namespace DSTStatus {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kDSTOffsetActive), DSTOffsetActive));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kDSTOffsetActive))
        {
            err = DataModel::Decode(reader, DSTOffsetActive);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace DSTStatus.
namespace TimeZoneStatus {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kOffset), offset));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kName), name));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kOffset))
        {
            err = DataModel::Decode(reader, offset);
        }
        else if (__context_tag == to_underlying(Fields::kName))
        {
            err = DataModel::Decode(reader, name);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TimeZoneStatus.
namespace TimeFailure {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace TimeFailure.
namespace MissingTrustedTimeSource {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace MissingTrustedTimeSource.
} // namespace Events

} // namespace TimeSynchronization
namespace BridgedDeviceBasicInformation {
namespace Structs {

namespace ProductAppearanceStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kFinish), finish);
    encoder.Encode(to_underlying(Fields::kPrimaryColor), primaryColor);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kFinish))
        {
            err = DataModel::Decode(reader, finish);
        }
        else if (__context_tag == to_underlying(Fields::kPrimaryColor))
        {
            err = DataModel::Decode(reader, primaryColor);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ProductAppearanceStruct
} // namespace Structs

namespace Commands {
namespace KeepActive {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStayActiveDuration), stayActiveDuration);
    encoder.Encode(to_underlying(Fields::kTimeoutMs), timeoutMs);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStayActiveDuration))
        {
            err = DataModel::Decode(reader, stayActiveDuration);
        }
        else if (__context_tag == to_underlying(Fields::kTimeoutMs))
        {
            err = DataModel::Decode(reader, timeoutMs);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace KeepActive.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::VendorName::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, vendorName);
    case Attributes::VendorID::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, vendorID);
    case Attributes::ProductName::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, productName);
    case Attributes::ProductID::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, productID);
    case Attributes::NodeLabel::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nodeLabel);
    case Attributes::HardwareVersion::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, hardwareVersion);
    case Attributes::HardwareVersionString::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, hardwareVersionString);
    case Attributes::SoftwareVersion::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, softwareVersion);
    case Attributes::SoftwareVersionString::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, softwareVersionString);
    case Attributes::ManufacturingDate::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, manufacturingDate);
    case Attributes::PartNumber::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, partNumber);
    case Attributes::ProductURL::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, productURL);
    case Attributes::ProductLabel::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, productLabel);
    case Attributes::SerialNumber::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, serialNumber);
    case Attributes::Reachable::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, reachable);
    case Attributes::UniqueID::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, uniqueID);
    case Attributes::ProductAppearance::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, productAppearance);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace StartUp {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSoftwareVersion), softwareVersion));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kSoftwareVersion))
        {
            err = DataModel::Decode(reader, softwareVersion);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace StartUp.
namespace ShutDown {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace ShutDown.
namespace Leave {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace Leave.
namespace ReachableChanged {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kReachableNewValue), reachableNewValue));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kReachableNewValue))
        {
            err = DataModel::Decode(reader, reachableNewValue);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ReachableChanged.
namespace ActiveChanged {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPromisedActiveDuration), promisedActiveDuration));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kPromisedActiveDuration))
        {
            err = DataModel::Decode(reader, promisedActiveDuration);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ActiveChanged.
} // namespace Events

} // namespace BridgedDeviceBasicInformation
namespace Switch {

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::NumberOfPositions::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, numberOfPositions);
    case Attributes::CurrentPosition::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentPosition);
    case Attributes::MultiPressMax::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, multiPressMax);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace SwitchLatched {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kNewPosition), newPosition));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNewPosition))
        {
            err = DataModel::Decode(reader, newPosition);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SwitchLatched.
namespace InitialPress {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kNewPosition), newPosition));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNewPosition))
        {
            err = DataModel::Decode(reader, newPosition);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace InitialPress.
namespace LongPress {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kNewPosition), newPosition));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNewPosition))
        {
            err = DataModel::Decode(reader, newPosition);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace LongPress.
namespace ShortRelease {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPreviousPosition), previousPosition));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kPreviousPosition))
        {
            err = DataModel::Decode(reader, previousPosition);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ShortRelease.
namespace LongRelease {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPreviousPosition), previousPosition));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kPreviousPosition))
        {
            err = DataModel::Decode(reader, previousPosition);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace LongRelease.
namespace MultiPressOngoing {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kNewPosition), newPosition));
    ReturnErrorOnFailure(
        DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrentNumberOfPressesCounted), currentNumberOfPressesCounted));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNewPosition))
        {
            err = DataModel::Decode(reader, newPosition);
        }
        else if (__context_tag == to_underlying(Fields::kCurrentNumberOfPressesCounted))
        {
            err = DataModel::Decode(reader, currentNumberOfPressesCounted);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace MultiPressOngoing.
namespace MultiPressComplete {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPreviousPosition), previousPosition));
    ReturnErrorOnFailure(
        DataModel::Encode(aWriter, TLV::ContextTag(Fields::kTotalNumberOfPressesCounted), totalNumberOfPressesCounted));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kPreviousPosition))
        {
            err = DataModel::Decode(reader, previousPosition);
        }
        else if (__context_tag == to_underlying(Fields::kTotalNumberOfPressesCounted))
        {
            err = DataModel::Decode(reader, totalNumberOfPressesCounted);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace MultiPressComplete.
} // namespace Events

} // namespace Switch
namespace AdministratorCommissioning {

namespace Commands {
namespace OpenCommissioningWindow {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kCommissioningTimeout), commissioningTimeout);
    encoder.Encode(to_underlying(Fields::kPAKEPasscodeVerifier), PAKEPasscodeVerifier);
    encoder.Encode(to_underlying(Fields::kDiscriminator), discriminator);
    encoder.Encode(to_underlying(Fields::kIterations), iterations);
    encoder.Encode(to_underlying(Fields::kSalt), salt);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCommissioningTimeout))
        {
            err = DataModel::Decode(reader, commissioningTimeout);
        }
        else if (__context_tag == to_underlying(Fields::kPAKEPasscodeVerifier))
        {
            err = DataModel::Decode(reader, PAKEPasscodeVerifier);
        }
        else if (__context_tag == to_underlying(Fields::kDiscriminator))
        {
            err = DataModel::Decode(reader, discriminator);
        }
        else if (__context_tag == to_underlying(Fields::kIterations))
        {
            err = DataModel::Decode(reader, iterations);
        }
        else if (__context_tag == to_underlying(Fields::kSalt))
        {
            err = DataModel::Decode(reader, salt);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace OpenCommissioningWindow.
namespace OpenBasicCommissioningWindow {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kCommissioningTimeout), commissioningTimeout);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCommissioningTimeout))
        {
            err = DataModel::Decode(reader, commissioningTimeout);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace OpenBasicCommissioningWindow.
namespace RevokeCommissioning {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace RevokeCommissioning.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::WindowStatus::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, windowStatus);
    case Attributes::AdminFabricIndex::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, adminFabricIndex);
    case Attributes::AdminVendorId::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, adminVendorId);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace AdministratorCommissioning
namespace OperationalCredentials {
namespace Structs {

namespace FabricDescriptorStruct {
CHIP_ERROR Type::EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    return DoEncode(aWriter, aTag, NullOptional);
}

CHIP_ERROR Type::EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const
{
    return DoEncode(aWriter, aTag, MakeOptional(aAccessingFabricIndex));
}

CHIP_ERROR Type::DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const
{

    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };

    encoder.Encode(to_underlying(Fields::kRootPublicKey), rootPublicKey);
    encoder.Encode(to_underlying(Fields::kVendorID), vendorID);
    encoder.Encode(to_underlying(Fields::kFabricID), fabricID);
    encoder.Encode(to_underlying(Fields::kNodeID), nodeID);
    encoder.Encode(to_underlying(Fields::kLabel), label);
    if (aAccessingFabricIndex.HasValue())
    {
        encoder.Encode(to_underlying(Fields::kFabricIndex), fabricIndex);
    }

    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kRootPublicKey))
        {
            err = DataModel::Decode(reader, rootPublicKey);
        }
        else if (__context_tag == to_underlying(Fields::kVendorID))
        {
            err = DataModel::Decode(reader, vendorID);
        }
        else if (__context_tag == to_underlying(Fields::kFabricID))
        {
            err = DataModel::Decode(reader, fabricID);
        }
        else if (__context_tag == to_underlying(Fields::kNodeID))
        {
            err = DataModel::Decode(reader, nodeID);
        }
        else if (__context_tag == to_underlying(Fields::kLabel))
        {
            err = DataModel::Decode(reader, label);
        }
        else if (__context_tag == to_underlying(Fields::kFabricIndex))
        {
            err = DataModel::Decode(reader, fabricIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace FabricDescriptorStruct

namespace NOCStruct {
CHIP_ERROR Type::EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    return DoEncode(aWriter, aTag, NullOptional);
}

CHIP_ERROR Type::EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const
{
    return DoEncode(aWriter, aTag, MakeOptional(aAccessingFabricIndex));
}

CHIP_ERROR Type::DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const
{
    bool includeSensitive = !aAccessingFabricIndex.HasValue() || (aAccessingFabricIndex.Value() == fabricIndex);

    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };

    if (includeSensitive)
    {
        encoder.Encode(to_underlying(Fields::kNoc), noc);
    }
    if (includeSensitive)
    {
        encoder.Encode(to_underlying(Fields::kIcac), icac);
    }
    if (aAccessingFabricIndex.HasValue())
    {
        encoder.Encode(to_underlying(Fields::kFabricIndex), fabricIndex);
    }

    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNoc))
        {
            err = DataModel::Decode(reader, noc);
        }
        else if (__context_tag == to_underlying(Fields::kIcac))
        {
            err = DataModel::Decode(reader, icac);
        }
        else if (__context_tag == to_underlying(Fields::kFabricIndex))
        {
            err = DataModel::Decode(reader, fabricIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace NOCStruct
} // namespace Structs

namespace Commands {
namespace AttestationRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kAttestationNonce), attestationNonce);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kAttestationNonce))
        {
            err = DataModel::Decode(reader, attestationNonce);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace AttestationRequest.
namespace AttestationResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kAttestationElements), attestationElements);
    encoder.Encode(to_underlying(Fields::kAttestationSignature), attestationSignature);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kAttestationElements))
        {
            err = DataModel::Decode(reader, attestationElements);
        }
        else if (__context_tag == to_underlying(Fields::kAttestationSignature))
        {
            err = DataModel::Decode(reader, attestationSignature);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace AttestationResponse.
namespace CertificateChainRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kCertificateType), certificateType);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCertificateType))
        {
            err = DataModel::Decode(reader, certificateType);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace CertificateChainRequest.
namespace CertificateChainResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kCertificate), certificate);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCertificate))
        {
            err = DataModel::Decode(reader, certificate);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace CertificateChainResponse.
namespace CSRRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kCSRNonce), CSRNonce);
    encoder.Encode(to_underlying(Fields::kIsForUpdateNOC), isForUpdateNOC);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCSRNonce))
        {
            err = DataModel::Decode(reader, CSRNonce);
        }
        else if (__context_tag == to_underlying(Fields::kIsForUpdateNOC))
        {
            err = DataModel::Decode(reader, isForUpdateNOC);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace CSRRequest.
namespace CSRResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kNOCSRElements), NOCSRElements);
    encoder.Encode(to_underlying(Fields::kAttestationSignature), attestationSignature);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNOCSRElements))
        {
            err = DataModel::Decode(reader, NOCSRElements);
        }
        else if (__context_tag == to_underlying(Fields::kAttestationSignature))
        {
            err = DataModel::Decode(reader, attestationSignature);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace CSRResponse.
namespace AddNOC {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kNOCValue), NOCValue);
    encoder.Encode(to_underlying(Fields::kICACValue), ICACValue);
    encoder.Encode(to_underlying(Fields::kIPKValue), IPKValue);
    encoder.Encode(to_underlying(Fields::kCaseAdminSubject), caseAdminSubject);
    encoder.Encode(to_underlying(Fields::kAdminVendorId), adminVendorId);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNOCValue))
        {
            err = DataModel::Decode(reader, NOCValue);
        }
        else if (__context_tag == to_underlying(Fields::kICACValue))
        {
            err = DataModel::Decode(reader, ICACValue);
        }
        else if (__context_tag == to_underlying(Fields::kIPKValue))
        {
            err = DataModel::Decode(reader, IPKValue);
        }
        else if (__context_tag == to_underlying(Fields::kCaseAdminSubject))
        {
            err = DataModel::Decode(reader, caseAdminSubject);
        }
        else if (__context_tag == to_underlying(Fields::kAdminVendorId))
        {
            err = DataModel::Decode(reader, adminVendorId);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace AddNOC.
namespace UpdateNOC {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kNOCValue), NOCValue);
    encoder.Encode(to_underlying(Fields::kICACValue), ICACValue);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNOCValue))
        {
            err = DataModel::Decode(reader, NOCValue);
        }
        else if (__context_tag == to_underlying(Fields::kICACValue))
        {
            err = DataModel::Decode(reader, ICACValue);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace UpdateNOC.
namespace NOCResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStatusCode), statusCode);
    encoder.Encode(to_underlying(Fields::kFabricIndex), fabricIndex);
    encoder.Encode(to_underlying(Fields::kDebugText), debugText);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStatusCode))
        {
            err = DataModel::Decode(reader, statusCode);
        }
        else if (__context_tag == to_underlying(Fields::kFabricIndex))
        {
            err = DataModel::Decode(reader, fabricIndex);
        }
        else if (__context_tag == to_underlying(Fields::kDebugText))
        {
            err = DataModel::Decode(reader, debugText);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace NOCResponse.
namespace UpdateFabricLabel {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kLabel), label);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kLabel))
        {
            err = DataModel::Decode(reader, label);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace UpdateFabricLabel.
namespace RemoveFabric {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kFabricIndex), fabricIndex);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kFabricIndex))
        {
            err = DataModel::Decode(reader, fabricIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace RemoveFabric.
namespace AddTrustedRootCertificate {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kRootCACertificate), rootCACertificate);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kRootCACertificate))
        {
            err = DataModel::Decode(reader, rootCACertificate);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace AddTrustedRootCertificate.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::NOCs::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, NOCs);
    case Attributes::Fabrics::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, fabrics);
    case Attributes::SupportedFabrics::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, supportedFabrics);
    case Attributes::CommissionedFabrics::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, commissionedFabrics);
    case Attributes::TrustedRootCertificates::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, trustedRootCertificates);
    case Attributes::CurrentFabricIndex::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentFabricIndex);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace OperationalCredentials
namespace GroupKeyManagement {
namespace Structs {

namespace GroupInfoMapStruct {
CHIP_ERROR Type::EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    return DoEncode(aWriter, aTag, NullOptional);
}

CHIP_ERROR Type::EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const
{
    return DoEncode(aWriter, aTag, MakeOptional(aAccessingFabricIndex));
}

CHIP_ERROR Type::DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const
{

    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };

    encoder.Encode(to_underlying(Fields::kGroupId), groupId);
    encoder.Encode(to_underlying(Fields::kEndpoints), endpoints);
    encoder.Encode(to_underlying(Fields::kGroupName), groupName);
    if (aAccessingFabricIndex.HasValue())
    {
        encoder.Encode(to_underlying(Fields::kFabricIndex), fabricIndex);
    }

    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kGroupId))
        {
            err = DataModel::Decode(reader, groupId);
        }
        else if (__context_tag == to_underlying(Fields::kEndpoints))
        {
            err = DataModel::Decode(reader, endpoints);
        }
        else if (__context_tag == to_underlying(Fields::kGroupName))
        {
            err = DataModel::Decode(reader, groupName);
        }
        else if (__context_tag == to_underlying(Fields::kFabricIndex))
        {
            err = DataModel::Decode(reader, fabricIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace GroupInfoMapStruct

namespace GroupKeyMapStruct {
CHIP_ERROR Type::EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    return DoEncode(aWriter, aTag, NullOptional);
}

CHIP_ERROR Type::EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const
{
    return DoEncode(aWriter, aTag, MakeOptional(aAccessingFabricIndex));
}

CHIP_ERROR Type::DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const
{

    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };

    encoder.Encode(to_underlying(Fields::kGroupId), groupId);
    encoder.Encode(to_underlying(Fields::kGroupKeySetID), groupKeySetID);
    if (aAccessingFabricIndex.HasValue())
    {
        encoder.Encode(to_underlying(Fields::kFabricIndex), fabricIndex);
    }

    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kGroupId))
        {
            err = DataModel::Decode(reader, groupId);
        }
        else if (__context_tag == to_underlying(Fields::kGroupKeySetID))
        {
            err = DataModel::Decode(reader, groupKeySetID);
        }
        else if (__context_tag == to_underlying(Fields::kFabricIndex))
        {
            err = DataModel::Decode(reader, fabricIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace GroupKeyMapStruct

namespace GroupKeySetStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kGroupKeySetID), groupKeySetID);
    encoder.Encode(to_underlying(Fields::kGroupKeySecurityPolicy), groupKeySecurityPolicy);
    encoder.Encode(to_underlying(Fields::kEpochKey0), epochKey0);
    encoder.Encode(to_underlying(Fields::kEpochStartTime0), epochStartTime0);
    encoder.Encode(to_underlying(Fields::kEpochKey1), epochKey1);
    encoder.Encode(to_underlying(Fields::kEpochStartTime1), epochStartTime1);
    encoder.Encode(to_underlying(Fields::kEpochKey2), epochKey2);
    encoder.Encode(to_underlying(Fields::kEpochStartTime2), epochStartTime2);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kGroupKeySetID))
        {
            err = DataModel::Decode(reader, groupKeySetID);
        }
        else if (__context_tag == to_underlying(Fields::kGroupKeySecurityPolicy))
        {
            err = DataModel::Decode(reader, groupKeySecurityPolicy);
        }
        else if (__context_tag == to_underlying(Fields::kEpochKey0))
        {
            err = DataModel::Decode(reader, epochKey0);
        }
        else if (__context_tag == to_underlying(Fields::kEpochStartTime0))
        {
            err = DataModel::Decode(reader, epochStartTime0);
        }
        else if (__context_tag == to_underlying(Fields::kEpochKey1))
        {
            err = DataModel::Decode(reader, epochKey1);
        }
        else if (__context_tag == to_underlying(Fields::kEpochStartTime1))
        {
            err = DataModel::Decode(reader, epochStartTime1);
        }
        else if (__context_tag == to_underlying(Fields::kEpochKey2))
        {
            err = DataModel::Decode(reader, epochKey2);
        }
        else if (__context_tag == to_underlying(Fields::kEpochStartTime2))
        {
            err = DataModel::Decode(reader, epochStartTime2);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace GroupKeySetStruct
} // namespace Structs

namespace Commands {
namespace KeySetWrite {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kGroupKeySet), groupKeySet);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kGroupKeySet))
        {
            err = DataModel::Decode(reader, groupKeySet);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace KeySetWrite.
namespace KeySetRead {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kGroupKeySetID), groupKeySetID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kGroupKeySetID))
        {
            err = DataModel::Decode(reader, groupKeySetID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace KeySetRead.
namespace KeySetReadResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kGroupKeySet), groupKeySet);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kGroupKeySet))
        {
            err = DataModel::Decode(reader, groupKeySet);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace KeySetReadResponse.
namespace KeySetRemove {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kGroupKeySetID), groupKeySetID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kGroupKeySetID))
        {
            err = DataModel::Decode(reader, groupKeySetID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace KeySetRemove.
namespace KeySetReadAllIndices {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace KeySetReadAllIndices.
namespace KeySetReadAllIndicesResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kGroupKeySetIDs), groupKeySetIDs);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kGroupKeySetIDs))
        {
            err = DataModel::Decode(reader, groupKeySetIDs);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace KeySetReadAllIndicesResponse.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::GroupKeyMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, groupKeyMap);
    case Attributes::GroupTable::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, groupTable);
    case Attributes::MaxGroupsPerFabric::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxGroupsPerFabric);
    case Attributes::MaxGroupKeysPerFabric::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxGroupKeysPerFabric);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace GroupKeyManagement
namespace FixedLabel {
namespace Structs {} // namespace Structs

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::LabelList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, labelList);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace FixedLabel
namespace UserLabel {
namespace Structs {} // namespace Structs

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::LabelList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, labelList);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace UserLabel
namespace ProxyConfiguration {

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace ProxyConfiguration
namespace ProxyDiscovery {

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace ProxyDiscovery
namespace ProxyValid {

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace ProxyValid
namespace BooleanState {

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::StateValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, stateValue);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace StateChange {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kStateValue), stateValue));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStateValue))
        {
            err = DataModel::Decode(reader, stateValue);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace StateChange.
} // namespace Events

} // namespace BooleanState
namespace IcdManagement {
namespace Structs {

namespace MonitoringRegistrationStruct {
CHIP_ERROR Type::EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    return DoEncode(aWriter, aTag, NullOptional);
}

CHIP_ERROR Type::EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const
{
    return DoEncode(aWriter, aTag, MakeOptional(aAccessingFabricIndex));
}

CHIP_ERROR Type::DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const
{
    bool includeSensitive = !aAccessingFabricIndex.HasValue() || (aAccessingFabricIndex.Value() == fabricIndex);

    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };

    if (includeSensitive)
    {
        encoder.Encode(to_underlying(Fields::kCheckInNodeID), checkInNodeID);
    }
    if (includeSensitive)
    {
        encoder.Encode(to_underlying(Fields::kMonitoredSubject), monitoredSubject);
    }
    if (includeSensitive)
    {
        encoder.Encode(to_underlying(Fields::kClientType), clientType);
    }
    if (aAccessingFabricIndex.HasValue())
    {
        encoder.Encode(to_underlying(Fields::kFabricIndex), fabricIndex);
    }

    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCheckInNodeID))
        {
            err = DataModel::Decode(reader, checkInNodeID);
        }
        else if (__context_tag == to_underlying(Fields::kMonitoredSubject))
        {
            err = DataModel::Decode(reader, monitoredSubject);
        }
        else if (__context_tag == to_underlying(Fields::kClientType))
        {
            err = DataModel::Decode(reader, clientType);
        }
        else if (__context_tag == to_underlying(Fields::kFabricIndex))
        {
            err = DataModel::Decode(reader, fabricIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace MonitoringRegistrationStruct
} // namespace Structs

namespace Commands {
namespace RegisterClient {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kCheckInNodeID), checkInNodeID);
    encoder.Encode(to_underlying(Fields::kMonitoredSubject), monitoredSubject);
    encoder.Encode(to_underlying(Fields::kKey), key);
    encoder.Encode(to_underlying(Fields::kVerificationKey), verificationKey);
    encoder.Encode(to_underlying(Fields::kClientType), clientType);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCheckInNodeID))
        {
            err = DataModel::Decode(reader, checkInNodeID);
        }
        else if (__context_tag == to_underlying(Fields::kMonitoredSubject))
        {
            err = DataModel::Decode(reader, monitoredSubject);
        }
        else if (__context_tag == to_underlying(Fields::kKey))
        {
            err = DataModel::Decode(reader, key);
        }
        else if (__context_tag == to_underlying(Fields::kVerificationKey))
        {
            err = DataModel::Decode(reader, verificationKey);
        }
        else if (__context_tag == to_underlying(Fields::kClientType))
        {
            err = DataModel::Decode(reader, clientType);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace RegisterClient.
namespace RegisterClientResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kICDCounter), ICDCounter);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kICDCounter))
        {
            err = DataModel::Decode(reader, ICDCounter);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace RegisterClientResponse.
namespace UnregisterClient {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kCheckInNodeID), checkInNodeID);
    encoder.Encode(to_underlying(Fields::kVerificationKey), verificationKey);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCheckInNodeID))
        {
            err = DataModel::Decode(reader, checkInNodeID);
        }
        else if (__context_tag == to_underlying(Fields::kVerificationKey))
        {
            err = DataModel::Decode(reader, verificationKey);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace UnregisterClient.
namespace StayActiveRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStayActiveDuration), stayActiveDuration);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStayActiveDuration))
        {
            err = DataModel::Decode(reader, stayActiveDuration);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace StayActiveRequest.
namespace StayActiveResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kPromisedActiveDuration), promisedActiveDuration);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kPromisedActiveDuration))
        {
            err = DataModel::Decode(reader, promisedActiveDuration);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace StayActiveResponse.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::IdleModeDuration::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, idleModeDuration);
    case Attributes::ActiveModeDuration::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, activeModeDuration);
    case Attributes::ActiveModeThreshold::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, activeModeThreshold);
    case Attributes::RegisteredClients::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, registeredClients);
    case Attributes::ICDCounter::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, ICDCounter);
    case Attributes::ClientsSupportedPerFabric::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clientsSupportedPerFabric);
    case Attributes::UserActiveModeTriggerHint::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, userActiveModeTriggerHint);
    case Attributes::UserActiveModeTriggerInstruction::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, userActiveModeTriggerInstruction);
    case Attributes::OperatingMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, operatingMode);
    case Attributes::MaximumCheckInBackOff::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maximumCheckInBackOff);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace IcdManagement
namespace Timer {

namespace Commands {
namespace SetTimer {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kNewTime), newTime);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNewTime))
        {
            err = DataModel::Decode(reader, newTime);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetTimer.
namespace ResetTimer {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace ResetTimer.
namespace AddTime {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kAdditionalTime), additionalTime);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kAdditionalTime))
        {
            err = DataModel::Decode(reader, additionalTime);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace AddTime.
namespace ReduceTime {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kTimeReduction), timeReduction);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kTimeReduction))
        {
            err = DataModel::Decode(reader, timeReduction);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ReduceTime.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::SetTime::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, setTime);
    case Attributes::TimeRemaining::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, timeRemaining);
    case Attributes::TimerState::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, timerState);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace Timer
namespace OvenCavityOperationalState {
namespace Structs {} // namespace Structs

namespace Commands {
namespace Pause {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace Pause.
namespace Stop {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace Stop.
namespace Start {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace Start.
namespace Resume {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace Resume.
namespace OperationalCommandResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kCommandResponseState), commandResponseState);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCommandResponseState))
        {
            err = DataModel::Decode(reader, commandResponseState);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace OperationalCommandResponse.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::PhaseList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, phaseList);
    case Attributes::CurrentPhase::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentPhase);
    case Attributes::CountdownTime::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, countdownTime);
    case Attributes::OperationalStateList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, operationalStateList);
    case Attributes::OperationalState::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, operationalState);
    case Attributes::OperationalError::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, operationalError);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace OperationalError {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kErrorState), errorState));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kErrorState))
        {
            err = DataModel::Decode(reader, errorState);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace OperationalError.
namespace OperationCompletion {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCompletionErrorCode), completionErrorCode));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kTotalOperationalTime), totalOperationalTime));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPausedTime), pausedTime));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCompletionErrorCode))
        {
            err = DataModel::Decode(reader, completionErrorCode);
        }
        else if (__context_tag == to_underlying(Fields::kTotalOperationalTime))
        {
            err = DataModel::Decode(reader, totalOperationalTime);
        }
        else if (__context_tag == to_underlying(Fields::kPausedTime))
        {
            err = DataModel::Decode(reader, pausedTime);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace OperationCompletion.
} // namespace Events

} // namespace OvenCavityOperationalState
namespace OvenMode {
namespace Structs {} // namespace Structs

namespace Commands {
namespace ChangeToMode {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kNewMode), newMode);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNewMode))
        {
            err = DataModel::Decode(reader, newMode);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ChangeToMode.
namespace ChangeToModeResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kStatusText), statusText);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kStatusText))
        {
            err = DataModel::Decode(reader, statusText);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ChangeToModeResponse.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::SupportedModes::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, supportedModes);
    case Attributes::CurrentMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentMode);
    case Attributes::StartUpMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, startUpMode);
    case Attributes::OnMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, onMode);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace OvenMode
namespace LaundryDryerControls {

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::SupportedDrynessLevels::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, supportedDrynessLevels);
    case Attributes::SelectedDrynessLevel::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, selectedDrynessLevel);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace LaundryDryerControls
namespace ModeSelect {
namespace Structs {

namespace SemanticTagStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kMfgCode), mfgCode);
    encoder.Encode(to_underlying(Fields::kValue), value);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kMfgCode))
        {
            err = DataModel::Decode(reader, mfgCode);
        }
        else if (__context_tag == to_underlying(Fields::kValue))
        {
            err = DataModel::Decode(reader, value);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace SemanticTagStruct

namespace ModeOptionStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kLabel), label);
    encoder.Encode(to_underlying(Fields::kMode), mode);
    encoder.Encode(to_underlying(Fields::kSemanticTags), semanticTags);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kLabel))
        {
            err = DataModel::Decode(reader, label);
        }
        else if (__context_tag == to_underlying(Fields::kMode))
        {
            err = DataModel::Decode(reader, mode);
        }
        else if (__context_tag == to_underlying(Fields::kSemanticTags))
        {
            err = DataModel::Decode(reader, semanticTags);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ModeOptionStruct
} // namespace Structs

namespace Commands {
namespace ChangeToMode {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kNewMode), newMode);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNewMode))
        {
            err = DataModel::Decode(reader, newMode);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ChangeToMode.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::Description::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, description);
    case Attributes::StandardNamespace::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, standardNamespace);
    case Attributes::SupportedModes::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, supportedModes);
    case Attributes::CurrentMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentMode);
    case Attributes::StartUpMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, startUpMode);
    case Attributes::OnMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, onMode);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace ModeSelect
namespace LaundryWasherMode {
namespace Structs {} // namespace Structs

namespace Commands {
namespace ChangeToMode {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kNewMode), newMode);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNewMode))
        {
            err = DataModel::Decode(reader, newMode);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ChangeToMode.
namespace ChangeToModeResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kStatusText), statusText);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kStatusText))
        {
            err = DataModel::Decode(reader, statusText);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ChangeToModeResponse.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::SupportedModes::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, supportedModes);
    case Attributes::CurrentMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentMode);
    case Attributes::StartUpMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, startUpMode);
    case Attributes::OnMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, onMode);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace LaundryWasherMode
namespace RefrigeratorAndTemperatureControlledCabinetMode {
namespace Structs {} // namespace Structs

namespace Commands {
namespace ChangeToMode {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kNewMode), newMode);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNewMode))
        {
            err = DataModel::Decode(reader, newMode);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ChangeToMode.
namespace ChangeToModeResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kStatusText), statusText);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kStatusText))
        {
            err = DataModel::Decode(reader, statusText);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ChangeToModeResponse.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::SupportedModes::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, supportedModes);
    case Attributes::CurrentMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentMode);
    case Attributes::StartUpMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, startUpMode);
    case Attributes::OnMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, onMode);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace RefrigeratorAndTemperatureControlledCabinetMode
namespace LaundryWasherControls {

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::SpinSpeeds::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, spinSpeeds);
    case Attributes::SpinSpeedCurrent::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, spinSpeedCurrent);
    case Attributes::NumberOfRinses::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, numberOfRinses);
    case Attributes::SupportedRinses::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, supportedRinses);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace LaundryWasherControls
namespace RvcRunMode {
namespace Structs {} // namespace Structs

namespace Commands {
namespace ChangeToMode {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kNewMode), newMode);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNewMode))
        {
            err = DataModel::Decode(reader, newMode);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ChangeToMode.
namespace ChangeToModeResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kStatusText), statusText);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kStatusText))
        {
            err = DataModel::Decode(reader, statusText);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ChangeToModeResponse.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::SupportedModes::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, supportedModes);
    case Attributes::CurrentMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentMode);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace RvcRunMode
namespace RvcCleanMode {
namespace Structs {} // namespace Structs

namespace Commands {
namespace ChangeToMode {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kNewMode), newMode);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNewMode))
        {
            err = DataModel::Decode(reader, newMode);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ChangeToMode.
namespace ChangeToModeResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kStatusText), statusText);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kStatusText))
        {
            err = DataModel::Decode(reader, statusText);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ChangeToModeResponse.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::SupportedModes::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, supportedModes);
    case Attributes::CurrentMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentMode);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace RvcCleanMode
namespace TemperatureControl {

namespace Commands {
namespace SetTemperature {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kTargetTemperature), targetTemperature);
    encoder.Encode(to_underlying(Fields::kTargetTemperatureLevel), targetTemperatureLevel);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kTargetTemperature))
        {
            err = DataModel::Decode(reader, targetTemperature);
        }
        else if (__context_tag == to_underlying(Fields::kTargetTemperatureLevel))
        {
            err = DataModel::Decode(reader, targetTemperatureLevel);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetTemperature.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::TemperatureSetpoint::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, temperatureSetpoint);
    case Attributes::MinTemperature::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, minTemperature);
    case Attributes::MaxTemperature::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxTemperature);
    case Attributes::Step::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, step);
    case Attributes::SelectedTemperatureLevel::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, selectedTemperatureLevel);
    case Attributes::SupportedTemperatureLevels::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, supportedTemperatureLevels);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace TemperatureControl
namespace RefrigeratorAlarm {

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::Mask::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, mask);
    case Attributes::State::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, state);
    case Attributes::Supported::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, supported);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace Notify {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kActive), active));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kInactive), inactive));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kState), state));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMask), mask));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kActive))
        {
            err = DataModel::Decode(reader, active);
        }
        else if (__context_tag == to_underlying(Fields::kInactive))
        {
            err = DataModel::Decode(reader, inactive);
        }
        else if (__context_tag == to_underlying(Fields::kState))
        {
            err = DataModel::Decode(reader, state);
        }
        else if (__context_tag == to_underlying(Fields::kMask))
        {
            err = DataModel::Decode(reader, mask);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace Notify.
} // namespace Events

} // namespace RefrigeratorAlarm
namespace DishwasherMode {
namespace Structs {} // namespace Structs

namespace Commands {
namespace ChangeToMode {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kNewMode), newMode);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNewMode))
        {
            err = DataModel::Decode(reader, newMode);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ChangeToMode.
namespace ChangeToModeResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kStatusText), statusText);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kStatusText))
        {
            err = DataModel::Decode(reader, statusText);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ChangeToModeResponse.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::SupportedModes::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, supportedModes);
    case Attributes::CurrentMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentMode);
    case Attributes::StartUpMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, startUpMode);
    case Attributes::OnMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, onMode);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace DishwasherMode
namespace AirQuality {

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::AirQuality::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, airQuality);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace AirQuality
namespace SmokeCoAlarm {

namespace Commands {
namespace SelfTestRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace SelfTestRequest.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::ExpressedState::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, expressedState);
    case Attributes::SmokeState::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, smokeState);
    case Attributes::COState::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, COState);
    case Attributes::BatteryAlert::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, batteryAlert);
    case Attributes::DeviceMuted::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, deviceMuted);
    case Attributes::TestInProgress::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, testInProgress);
    case Attributes::HardwareFaultAlert::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, hardwareFaultAlert);
    case Attributes::EndOfServiceAlert::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, endOfServiceAlert);
    case Attributes::InterconnectSmokeAlarm::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, interconnectSmokeAlarm);
    case Attributes::InterconnectCOAlarm::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, interconnectCOAlarm);
    case Attributes::ContaminationState::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, contaminationState);
    case Attributes::SmokeSensitivityLevel::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, smokeSensitivityLevel);
    case Attributes::ExpiryDate::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, expiryDate);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace SmokeAlarm {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAlarmSeverityLevel), alarmSeverityLevel));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kAlarmSeverityLevel))
        {
            err = DataModel::Decode(reader, alarmSeverityLevel);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SmokeAlarm.
namespace COAlarm {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAlarmSeverityLevel), alarmSeverityLevel));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kAlarmSeverityLevel))
        {
            err = DataModel::Decode(reader, alarmSeverityLevel);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace COAlarm.
namespace LowBattery {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAlarmSeverityLevel), alarmSeverityLevel));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kAlarmSeverityLevel))
        {
            err = DataModel::Decode(reader, alarmSeverityLevel);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace LowBattery.
namespace HardwareFault {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace HardwareFault.
namespace EndOfService {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace EndOfService.
namespace SelfTestComplete {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace SelfTestComplete.
namespace AlarmMuted {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace AlarmMuted.
namespace MuteEnded {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace MuteEnded.
namespace InterconnectSmokeAlarm {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAlarmSeverityLevel), alarmSeverityLevel));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kAlarmSeverityLevel))
        {
            err = DataModel::Decode(reader, alarmSeverityLevel);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace InterconnectSmokeAlarm.
namespace InterconnectCOAlarm {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAlarmSeverityLevel), alarmSeverityLevel));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kAlarmSeverityLevel))
        {
            err = DataModel::Decode(reader, alarmSeverityLevel);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace InterconnectCOAlarm.
namespace AllClear {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace AllClear.
} // namespace Events

} // namespace SmokeCoAlarm
namespace DishwasherAlarm {

namespace Commands {
namespace Reset {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kAlarms), alarms);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kAlarms))
        {
            err = DataModel::Decode(reader, alarms);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace Reset.
namespace ModifyEnabledAlarms {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kMask), mask);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kMask))
        {
            err = DataModel::Decode(reader, mask);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ModifyEnabledAlarms.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::Mask::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, mask);
    case Attributes::Latch::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, latch);
    case Attributes::State::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, state);
    case Attributes::Supported::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, supported);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace Notify {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kActive), active));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kInactive), inactive));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kState), state));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMask), mask));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kActive))
        {
            err = DataModel::Decode(reader, active);
        }
        else if (__context_tag == to_underlying(Fields::kInactive))
        {
            err = DataModel::Decode(reader, inactive);
        }
        else if (__context_tag == to_underlying(Fields::kState))
        {
            err = DataModel::Decode(reader, state);
        }
        else if (__context_tag == to_underlying(Fields::kMask))
        {
            err = DataModel::Decode(reader, mask);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace Notify.
} // namespace Events

} // namespace DishwasherAlarm
namespace MicrowaveOvenMode {
namespace Structs {} // namespace Structs

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::SupportedModes::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, supportedModes);
    case Attributes::CurrentMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentMode);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace MicrowaveOvenMode
namespace MicrowaveOvenControl {

namespace Commands {
namespace SetCookingParameters {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kCookMode), cookMode);
    encoder.Encode(to_underlying(Fields::kCookTime), cookTime);
    encoder.Encode(to_underlying(Fields::kPowerSetting), powerSetting);
    encoder.Encode(to_underlying(Fields::kWattSettingIndex), wattSettingIndex);
    encoder.Encode(to_underlying(Fields::kStartAfterSetting), startAfterSetting);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCookMode))
        {
            err = DataModel::Decode(reader, cookMode);
        }
        else if (__context_tag == to_underlying(Fields::kCookTime))
        {
            err = DataModel::Decode(reader, cookTime);
        }
        else if (__context_tag == to_underlying(Fields::kPowerSetting))
        {
            err = DataModel::Decode(reader, powerSetting);
        }
        else if (__context_tag == to_underlying(Fields::kWattSettingIndex))
        {
            err = DataModel::Decode(reader, wattSettingIndex);
        }
        else if (__context_tag == to_underlying(Fields::kStartAfterSetting))
        {
            err = DataModel::Decode(reader, startAfterSetting);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetCookingParameters.
namespace AddMoreTime {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kTimeToAdd), timeToAdd);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kTimeToAdd))
        {
            err = DataModel::Decode(reader, timeToAdd);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace AddMoreTime.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::CookTime::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, cookTime);
    case Attributes::MaxCookTime::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxCookTime);
    case Attributes::PowerSetting::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, powerSetting);
    case Attributes::MinPower::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, minPower);
    case Attributes::MaxPower::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxPower);
    case Attributes::PowerStep::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, powerStep);
    case Attributes::SupportedWatts::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, supportedWatts);
    case Attributes::SelectedWattIndex::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, selectedWattIndex);
    case Attributes::WattRating::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, wattRating);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace MicrowaveOvenControl
namespace OperationalState {
namespace Structs {} // namespace Structs

namespace Commands {
namespace Pause {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace Pause.
namespace Stop {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace Stop.
namespace Start {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace Start.
namespace Resume {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace Resume.
namespace OperationalCommandResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kCommandResponseState), commandResponseState);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCommandResponseState))
        {
            err = DataModel::Decode(reader, commandResponseState);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace OperationalCommandResponse.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::PhaseList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, phaseList);
    case Attributes::CurrentPhase::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentPhase);
    case Attributes::CountdownTime::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, countdownTime);
    case Attributes::OperationalStateList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, operationalStateList);
    case Attributes::OperationalState::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, operationalState);
    case Attributes::OperationalError::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, operationalError);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace OperationalError {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kErrorState), errorState));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kErrorState))
        {
            err = DataModel::Decode(reader, errorState);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace OperationalError.
namespace OperationCompletion {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCompletionErrorCode), completionErrorCode));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kTotalOperationalTime), totalOperationalTime));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPausedTime), pausedTime));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCompletionErrorCode))
        {
            err = DataModel::Decode(reader, completionErrorCode);
        }
        else if (__context_tag == to_underlying(Fields::kTotalOperationalTime))
        {
            err = DataModel::Decode(reader, totalOperationalTime);
        }
        else if (__context_tag == to_underlying(Fields::kPausedTime))
        {
            err = DataModel::Decode(reader, pausedTime);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace OperationCompletion.
} // namespace Events

} // namespace OperationalState
namespace RvcOperationalState {
namespace Structs {} // namespace Structs

namespace Commands {
namespace Pause {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace Pause.
namespace Resume {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace Resume.
namespace OperationalCommandResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kCommandResponseState), commandResponseState);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCommandResponseState))
        {
            err = DataModel::Decode(reader, commandResponseState);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace OperationalCommandResponse.
namespace GoHome {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace GoHome.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::PhaseList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, phaseList);
    case Attributes::CurrentPhase::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentPhase);
    case Attributes::CountdownTime::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, countdownTime);
    case Attributes::OperationalStateList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, operationalStateList);
    case Attributes::OperationalState::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, operationalState);
    case Attributes::OperationalError::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, operationalError);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace OperationalError {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kErrorState), errorState));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kErrorState))
        {
            err = DataModel::Decode(reader, errorState);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace OperationalError.
namespace OperationCompletion {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCompletionErrorCode), completionErrorCode));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kTotalOperationalTime), totalOperationalTime));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPausedTime), pausedTime));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCompletionErrorCode))
        {
            err = DataModel::Decode(reader, completionErrorCode);
        }
        else if (__context_tag == to_underlying(Fields::kTotalOperationalTime))
        {
            err = DataModel::Decode(reader, totalOperationalTime);
        }
        else if (__context_tag == to_underlying(Fields::kPausedTime))
        {
            err = DataModel::Decode(reader, pausedTime);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace OperationCompletion.
} // namespace Events

} // namespace RvcOperationalState
namespace ScenesManagement {
namespace Structs {

namespace AttributeValuePairStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kAttributeID), attributeID);
    encoder.Encode(to_underlying(Fields::kValueUnsigned8), valueUnsigned8);
    encoder.Encode(to_underlying(Fields::kValueSigned8), valueSigned8);
    encoder.Encode(to_underlying(Fields::kValueUnsigned16), valueUnsigned16);
    encoder.Encode(to_underlying(Fields::kValueSigned16), valueSigned16);
    encoder.Encode(to_underlying(Fields::kValueUnsigned32), valueUnsigned32);
    encoder.Encode(to_underlying(Fields::kValueSigned32), valueSigned32);
    encoder.Encode(to_underlying(Fields::kValueUnsigned64), valueUnsigned64);
    encoder.Encode(to_underlying(Fields::kValueSigned64), valueSigned64);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kAttributeID))
        {
            err = DataModel::Decode(reader, attributeID);
        }
        else if (__context_tag == to_underlying(Fields::kValueUnsigned8))
        {
            err = DataModel::Decode(reader, valueUnsigned8);
        }
        else if (__context_tag == to_underlying(Fields::kValueSigned8))
        {
            err = DataModel::Decode(reader, valueSigned8);
        }
        else if (__context_tag == to_underlying(Fields::kValueUnsigned16))
        {
            err = DataModel::Decode(reader, valueUnsigned16);
        }
        else if (__context_tag == to_underlying(Fields::kValueSigned16))
        {
            err = DataModel::Decode(reader, valueSigned16);
        }
        else if (__context_tag == to_underlying(Fields::kValueUnsigned32))
        {
            err = DataModel::Decode(reader, valueUnsigned32);
        }
        else if (__context_tag == to_underlying(Fields::kValueSigned32))
        {
            err = DataModel::Decode(reader, valueSigned32);
        }
        else if (__context_tag == to_underlying(Fields::kValueUnsigned64))
        {
            err = DataModel::Decode(reader, valueUnsigned64);
        }
        else if (__context_tag == to_underlying(Fields::kValueSigned64))
        {
            err = DataModel::Decode(reader, valueSigned64);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace AttributeValuePairStruct

namespace ExtensionFieldSet {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kClusterID), clusterID);
    encoder.Encode(to_underlying(Fields::kAttributeValueList), attributeValueList);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kClusterID))
        {
            err = DataModel::Decode(reader, clusterID);
        }
        else if (__context_tag == to_underlying(Fields::kAttributeValueList))
        {
            err = DataModel::Decode(reader, attributeValueList);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ExtensionFieldSet

namespace SceneInfoStruct {
CHIP_ERROR Type::EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    return DoEncode(aWriter, aTag, NullOptional);
}

CHIP_ERROR Type::EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const
{
    return DoEncode(aWriter, aTag, MakeOptional(aAccessingFabricIndex));
}

CHIP_ERROR Type::DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const
{
    bool includeSensitive = !aAccessingFabricIndex.HasValue() || (aAccessingFabricIndex.Value() == fabricIndex);

    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };

    encoder.Encode(to_underlying(Fields::kSceneCount), sceneCount);
    if (includeSensitive)
    {
        encoder.Encode(to_underlying(Fields::kCurrentScene), currentScene);
    }
    if (includeSensitive)
    {
        encoder.Encode(to_underlying(Fields::kCurrentGroup), currentGroup);
    }
    if (includeSensitive)
    {
        encoder.Encode(to_underlying(Fields::kSceneValid), sceneValid);
    }
    encoder.Encode(to_underlying(Fields::kRemainingCapacity), remainingCapacity);
    if (aAccessingFabricIndex.HasValue())
    {
        encoder.Encode(to_underlying(Fields::kFabricIndex), fabricIndex);
    }

    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kSceneCount))
        {
            err = DataModel::Decode(reader, sceneCount);
        }
        else if (__context_tag == to_underlying(Fields::kCurrentScene))
        {
            err = DataModel::Decode(reader, currentScene);
        }
        else if (__context_tag == to_underlying(Fields::kCurrentGroup))
        {
            err = DataModel::Decode(reader, currentGroup);
        }
        else if (__context_tag == to_underlying(Fields::kSceneValid))
        {
            err = DataModel::Decode(reader, sceneValid);
        }
        else if (__context_tag == to_underlying(Fields::kRemainingCapacity))
        {
            err = DataModel::Decode(reader, remainingCapacity);
        }
        else if (__context_tag == to_underlying(Fields::kFabricIndex))
        {
            err = DataModel::Decode(reader, fabricIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace SceneInfoStruct
} // namespace Structs

namespace Commands {
namespace AddScene {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kGroupID), groupID);
    encoder.Encode(to_underlying(Fields::kSceneID), sceneID);
    encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
    encoder.Encode(to_underlying(Fields::kSceneName), sceneName);
    encoder.Encode(to_underlying(Fields::kExtensionFieldSets), extensionFieldSets);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kGroupID))
        {
            err = DataModel::Decode(reader, groupID);
        }
        else if (__context_tag == to_underlying(Fields::kSceneID))
        {
            err = DataModel::Decode(reader, sceneID);
        }
        else if (__context_tag == to_underlying(Fields::kTransitionTime))
        {
            err = DataModel::Decode(reader, transitionTime);
        }
        else if (__context_tag == to_underlying(Fields::kSceneName))
        {
            err = DataModel::Decode(reader, sceneName);
        }
        else if (__context_tag == to_underlying(Fields::kExtensionFieldSets))
        {
            err = DataModel::Decode(reader, extensionFieldSets);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace AddScene.
namespace AddSceneResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kGroupID), groupID);
    encoder.Encode(to_underlying(Fields::kSceneID), sceneID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kGroupID))
        {
            err = DataModel::Decode(reader, groupID);
        }
        else if (__context_tag == to_underlying(Fields::kSceneID))
        {
            err = DataModel::Decode(reader, sceneID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace AddSceneResponse.
namespace ViewScene {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kGroupID), groupID);
    encoder.Encode(to_underlying(Fields::kSceneID), sceneID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kGroupID))
        {
            err = DataModel::Decode(reader, groupID);
        }
        else if (__context_tag == to_underlying(Fields::kSceneID))
        {
            err = DataModel::Decode(reader, sceneID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ViewScene.
namespace ViewSceneResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kGroupID), groupID);
    encoder.Encode(to_underlying(Fields::kSceneID), sceneID);
    encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
    encoder.Encode(to_underlying(Fields::kSceneName), sceneName);
    encoder.Encode(to_underlying(Fields::kExtensionFieldSets), extensionFieldSets);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kGroupID))
        {
            err = DataModel::Decode(reader, groupID);
        }
        else if (__context_tag == to_underlying(Fields::kSceneID))
        {
            err = DataModel::Decode(reader, sceneID);
        }
        else if (__context_tag == to_underlying(Fields::kTransitionTime))
        {
            err = DataModel::Decode(reader, transitionTime);
        }
        else if (__context_tag == to_underlying(Fields::kSceneName))
        {
            err = DataModel::Decode(reader, sceneName);
        }
        else if (__context_tag == to_underlying(Fields::kExtensionFieldSets))
        {
            err = DataModel::Decode(reader, extensionFieldSets);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ViewSceneResponse.
namespace RemoveScene {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kGroupID), groupID);
    encoder.Encode(to_underlying(Fields::kSceneID), sceneID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kGroupID))
        {
            err = DataModel::Decode(reader, groupID);
        }
        else if (__context_tag == to_underlying(Fields::kSceneID))
        {
            err = DataModel::Decode(reader, sceneID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace RemoveScene.
namespace RemoveSceneResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kGroupID), groupID);
    encoder.Encode(to_underlying(Fields::kSceneID), sceneID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kGroupID))
        {
            err = DataModel::Decode(reader, groupID);
        }
        else if (__context_tag == to_underlying(Fields::kSceneID))
        {
            err = DataModel::Decode(reader, sceneID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace RemoveSceneResponse.
namespace RemoveAllScenes {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kGroupID), groupID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kGroupID))
        {
            err = DataModel::Decode(reader, groupID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace RemoveAllScenes.
namespace RemoveAllScenesResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kGroupID), groupID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kGroupID))
        {
            err = DataModel::Decode(reader, groupID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace RemoveAllScenesResponse.
namespace StoreScene {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kGroupID), groupID);
    encoder.Encode(to_underlying(Fields::kSceneID), sceneID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kGroupID))
        {
            err = DataModel::Decode(reader, groupID);
        }
        else if (__context_tag == to_underlying(Fields::kSceneID))
        {
            err = DataModel::Decode(reader, sceneID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace StoreScene.
namespace StoreSceneResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kGroupID), groupID);
    encoder.Encode(to_underlying(Fields::kSceneID), sceneID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kGroupID))
        {
            err = DataModel::Decode(reader, groupID);
        }
        else if (__context_tag == to_underlying(Fields::kSceneID))
        {
            err = DataModel::Decode(reader, sceneID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace StoreSceneResponse.
namespace RecallScene {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kGroupID), groupID);
    encoder.Encode(to_underlying(Fields::kSceneID), sceneID);
    encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kGroupID))
        {
            err = DataModel::Decode(reader, groupID);
        }
        else if (__context_tag == to_underlying(Fields::kSceneID))
        {
            err = DataModel::Decode(reader, sceneID);
        }
        else if (__context_tag == to_underlying(Fields::kTransitionTime))
        {
            err = DataModel::Decode(reader, transitionTime);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace RecallScene.
namespace GetSceneMembership {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kGroupID), groupID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kGroupID))
        {
            err = DataModel::Decode(reader, groupID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GetSceneMembership.
namespace GetSceneMembershipResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kCapacity), capacity);
    encoder.Encode(to_underlying(Fields::kGroupID), groupID);
    encoder.Encode(to_underlying(Fields::kSceneList), sceneList);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kCapacity))
        {
            err = DataModel::Decode(reader, capacity);
        }
        else if (__context_tag == to_underlying(Fields::kGroupID))
        {
            err = DataModel::Decode(reader, groupID);
        }
        else if (__context_tag == to_underlying(Fields::kSceneList))
        {
            err = DataModel::Decode(reader, sceneList);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GetSceneMembershipResponse.
namespace CopyScene {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kMode), mode);
    encoder.Encode(to_underlying(Fields::kGroupIdentifierFrom), groupIdentifierFrom);
    encoder.Encode(to_underlying(Fields::kSceneIdentifierFrom), sceneIdentifierFrom);
    encoder.Encode(to_underlying(Fields::kGroupIdentifierTo), groupIdentifierTo);
    encoder.Encode(to_underlying(Fields::kSceneIdentifierTo), sceneIdentifierTo);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kMode))
        {
            err = DataModel::Decode(reader, mode);
        }
        else if (__context_tag == to_underlying(Fields::kGroupIdentifierFrom))
        {
            err = DataModel::Decode(reader, groupIdentifierFrom);
        }
        else if (__context_tag == to_underlying(Fields::kSceneIdentifierFrom))
        {
            err = DataModel::Decode(reader, sceneIdentifierFrom);
        }
        else if (__context_tag == to_underlying(Fields::kGroupIdentifierTo))
        {
            err = DataModel::Decode(reader, groupIdentifierTo);
        }
        else if (__context_tag == to_underlying(Fields::kSceneIdentifierTo))
        {
            err = DataModel::Decode(reader, sceneIdentifierTo);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace CopyScene.
namespace CopySceneResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kGroupIdentifierFrom), groupIdentifierFrom);
    encoder.Encode(to_underlying(Fields::kSceneIdentifierFrom), sceneIdentifierFrom);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kGroupIdentifierFrom))
        {
            err = DataModel::Decode(reader, groupIdentifierFrom);
        }
        else if (__context_tag == to_underlying(Fields::kSceneIdentifierFrom))
        {
            err = DataModel::Decode(reader, sceneIdentifierFrom);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace CopySceneResponse.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::LastConfiguredBy::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, lastConfiguredBy);
    case Attributes::SceneTableSize::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, sceneTableSize);
    case Attributes::FabricSceneInfo::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, fabricSceneInfo);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace ScenesManagement
namespace HepaFilterMonitoring {
namespace Structs {

namespace ReplacementProductStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kProductIdentifierType), productIdentifierType);
    encoder.Encode(to_underlying(Fields::kProductIdentifierValue), productIdentifierValue);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kProductIdentifierType))
        {
            err = DataModel::Decode(reader, productIdentifierType);
        }
        else if (__context_tag == to_underlying(Fields::kProductIdentifierValue))
        {
            err = DataModel::Decode(reader, productIdentifierValue);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ReplacementProductStruct
} // namespace Structs

namespace Commands {
namespace ResetCondition {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace ResetCondition.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::Condition::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, condition);
    case Attributes::DegradationDirection::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, degradationDirection);
    case Attributes::ChangeIndication::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, changeIndication);
    case Attributes::InPlaceIndicator::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, inPlaceIndicator);
    case Attributes::LastChangedTime::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, lastChangedTime);
    case Attributes::ReplacementProductList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, replacementProductList);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace HepaFilterMonitoring
namespace ActivatedCarbonFilterMonitoring {
namespace Structs {

namespace ReplacementProductStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kProductIdentifierType), productIdentifierType);
    encoder.Encode(to_underlying(Fields::kProductIdentifierValue), productIdentifierValue);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kProductIdentifierType))
        {
            err = DataModel::Decode(reader, productIdentifierType);
        }
        else if (__context_tag == to_underlying(Fields::kProductIdentifierValue))
        {
            err = DataModel::Decode(reader, productIdentifierValue);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ReplacementProductStruct
} // namespace Structs

namespace Commands {
namespace ResetCondition {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace ResetCondition.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::Condition::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, condition);
    case Attributes::DegradationDirection::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, degradationDirection);
    case Attributes::ChangeIndication::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, changeIndication);
    case Attributes::InPlaceIndicator::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, inPlaceIndicator);
    case Attributes::LastChangedTime::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, lastChangedTime);
    case Attributes::ReplacementProductList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, replacementProductList);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace ActivatedCarbonFilterMonitoring
namespace BooleanStateConfiguration {

namespace Commands {
namespace SuppressAlarm {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kAlarmsToSuppress), alarmsToSuppress);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kAlarmsToSuppress))
        {
            err = DataModel::Decode(reader, alarmsToSuppress);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SuppressAlarm.
namespace EnableDisableAlarm {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kAlarmsToEnableDisable), alarmsToEnableDisable);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kAlarmsToEnableDisable))
        {
            err = DataModel::Decode(reader, alarmsToEnableDisable);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace EnableDisableAlarm.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::CurrentSensitivityLevel::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentSensitivityLevel);
    case Attributes::SupportedSensitivityLevels::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, supportedSensitivityLevels);
    case Attributes::DefaultSensitivityLevel::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, defaultSensitivityLevel);
    case Attributes::AlarmsActive::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, alarmsActive);
    case Attributes::AlarmsSuppressed::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, alarmsSuppressed);
    case Attributes::AlarmsEnabled::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, alarmsEnabled);
    case Attributes::AlarmsSupported::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, alarmsSupported);
    case Attributes::SensorFault::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, sensorFault);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace AlarmsStateChanged {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAlarmsActive), alarmsActive));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAlarmsSuppressed), alarmsSuppressed));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kAlarmsActive))
        {
            err = DataModel::Decode(reader, alarmsActive);
        }
        else if (__context_tag == to_underlying(Fields::kAlarmsSuppressed))
        {
            err = DataModel::Decode(reader, alarmsSuppressed);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace AlarmsStateChanged.
namespace SensorFault {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSensorFault), sensorFault));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kSensorFault))
        {
            err = DataModel::Decode(reader, sensorFault);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SensorFault.
} // namespace Events

} // namespace BooleanStateConfiguration
namespace ValveConfigurationAndControl {

namespace Commands {
namespace Open {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kOpenDuration), openDuration);
    encoder.Encode(to_underlying(Fields::kTargetLevel), targetLevel);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kOpenDuration))
        {
            err = DataModel::Decode(reader, openDuration);
        }
        else if (__context_tag == to_underlying(Fields::kTargetLevel))
        {
            err = DataModel::Decode(reader, targetLevel);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace Open.
namespace Close {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace Close.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::OpenDuration::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, openDuration);
    case Attributes::DefaultOpenDuration::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, defaultOpenDuration);
    case Attributes::AutoCloseTime::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, autoCloseTime);
    case Attributes::RemainingDuration::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, remainingDuration);
    case Attributes::CurrentState::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentState);
    case Attributes::TargetState::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, targetState);
    case Attributes::CurrentLevel::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentLevel);
    case Attributes::TargetLevel::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, targetLevel);
    case Attributes::DefaultOpenLevel::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, defaultOpenLevel);
    case Attributes::ValveFault::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, valveFault);
    case Attributes::LevelStep::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, levelStep);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace ValveStateChanged {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kValveState), valveState));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kValveLevel), valveLevel));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kValveState))
        {
            err = DataModel::Decode(reader, valveState);
        }
        else if (__context_tag == to_underlying(Fields::kValveLevel))
        {
            err = DataModel::Decode(reader, valveLevel);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ValveStateChanged.
namespace ValveFault {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kValveFault), valveFault));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kValveFault))
        {
            err = DataModel::Decode(reader, valveFault);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ValveFault.
} // namespace Events

} // namespace ValveConfigurationAndControl
namespace ElectricalPowerMeasurement {
namespace Structs {

namespace HarmonicMeasurementStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kOrder), order);
    encoder.Encode(to_underlying(Fields::kMeasurement), measurement);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kOrder))
        {
            err = DataModel::Decode(reader, order);
        }
        else if (__context_tag == to_underlying(Fields::kMeasurement))
        {
            err = DataModel::Decode(reader, measurement);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace HarmonicMeasurementStruct

namespace MeasurementRangeStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kMeasurementType), measurementType);
    encoder.Encode(to_underlying(Fields::kMin), min);
    encoder.Encode(to_underlying(Fields::kMax), max);
    encoder.Encode(to_underlying(Fields::kStartTimestamp), startTimestamp);
    encoder.Encode(to_underlying(Fields::kEndTimestamp), endTimestamp);
    encoder.Encode(to_underlying(Fields::kMinTimestamp), minTimestamp);
    encoder.Encode(to_underlying(Fields::kMaxTimestamp), maxTimestamp);
    encoder.Encode(to_underlying(Fields::kStartSystime), startSystime);
    encoder.Encode(to_underlying(Fields::kEndSystime), endSystime);
    encoder.Encode(to_underlying(Fields::kMinSystime), minSystime);
    encoder.Encode(to_underlying(Fields::kMaxSystime), maxSystime);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kMeasurementType))
        {
            err = DataModel::Decode(reader, measurementType);
        }
        else if (__context_tag == to_underlying(Fields::kMin))
        {
            err = DataModel::Decode(reader, min);
        }
        else if (__context_tag == to_underlying(Fields::kMax))
        {
            err = DataModel::Decode(reader, max);
        }
        else if (__context_tag == to_underlying(Fields::kStartTimestamp))
        {
            err = DataModel::Decode(reader, startTimestamp);
        }
        else if (__context_tag == to_underlying(Fields::kEndTimestamp))
        {
            err = DataModel::Decode(reader, endTimestamp);
        }
        else if (__context_tag == to_underlying(Fields::kMinTimestamp))
        {
            err = DataModel::Decode(reader, minTimestamp);
        }
        else if (__context_tag == to_underlying(Fields::kMaxTimestamp))
        {
            err = DataModel::Decode(reader, maxTimestamp);
        }
        else if (__context_tag == to_underlying(Fields::kStartSystime))
        {
            err = DataModel::Decode(reader, startSystime);
        }
        else if (__context_tag == to_underlying(Fields::kEndSystime))
        {
            err = DataModel::Decode(reader, endSystime);
        }
        else if (__context_tag == to_underlying(Fields::kMinSystime))
        {
            err = DataModel::Decode(reader, minSystime);
        }
        else if (__context_tag == to_underlying(Fields::kMaxSystime))
        {
            err = DataModel::Decode(reader, maxSystime);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace MeasurementRangeStruct
} // namespace Structs

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::PowerMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, powerMode);
    case Attributes::NumberOfMeasurementTypes::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, numberOfMeasurementTypes);
    case Attributes::Accuracy::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, accuracy);
    case Attributes::Ranges::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, ranges);
    case Attributes::Voltage::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, voltage);
    case Attributes::ActiveCurrent::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, activeCurrent);
    case Attributes::ReactiveCurrent::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, reactiveCurrent);
    case Attributes::ApparentCurrent::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, apparentCurrent);
    case Attributes::ActivePower::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, activePower);
    case Attributes::ReactivePower::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, reactivePower);
    case Attributes::ApparentPower::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, apparentPower);
    case Attributes::RMSVoltage::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, RMSVoltage);
    case Attributes::RMSCurrent::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, RMSCurrent);
    case Attributes::RMSPower::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, RMSPower);
    case Attributes::Frequency::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, frequency);
    case Attributes::HarmonicCurrents::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, harmonicCurrents);
    case Attributes::HarmonicPhases::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, harmonicPhases);
    case Attributes::PowerFactor::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, powerFactor);
    case Attributes::NeutralCurrent::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, neutralCurrent);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace MeasurementPeriodRanges {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kRanges), ranges));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kRanges))
        {
            err = DataModel::Decode(reader, ranges);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace MeasurementPeriodRanges.
} // namespace Events

} // namespace ElectricalPowerMeasurement
namespace ElectricalEnergyMeasurement {
namespace Structs {

namespace CumulativeEnergyResetStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kImportedResetTimestamp), importedResetTimestamp);
    encoder.Encode(to_underlying(Fields::kExportedResetTimestamp), exportedResetTimestamp);
    encoder.Encode(to_underlying(Fields::kImportedResetSystime), importedResetSystime);
    encoder.Encode(to_underlying(Fields::kExportedResetSystime), exportedResetSystime);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kImportedResetTimestamp))
        {
            err = DataModel::Decode(reader, importedResetTimestamp);
        }
        else if (__context_tag == to_underlying(Fields::kExportedResetTimestamp))
        {
            err = DataModel::Decode(reader, exportedResetTimestamp);
        }
        else if (__context_tag == to_underlying(Fields::kImportedResetSystime))
        {
            err = DataModel::Decode(reader, importedResetSystime);
        }
        else if (__context_tag == to_underlying(Fields::kExportedResetSystime))
        {
            err = DataModel::Decode(reader, exportedResetSystime);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace CumulativeEnergyResetStruct

namespace EnergyMeasurementStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kEnergy), energy);
    encoder.Encode(to_underlying(Fields::kStartTimestamp), startTimestamp);
    encoder.Encode(to_underlying(Fields::kEndTimestamp), endTimestamp);
    encoder.Encode(to_underlying(Fields::kStartSystime), startSystime);
    encoder.Encode(to_underlying(Fields::kEndSystime), endSystime);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kEnergy))
        {
            err = DataModel::Decode(reader, energy);
        }
        else if (__context_tag == to_underlying(Fields::kStartTimestamp))
        {
            err = DataModel::Decode(reader, startTimestamp);
        }
        else if (__context_tag == to_underlying(Fields::kEndTimestamp))
        {
            err = DataModel::Decode(reader, endTimestamp);
        }
        else if (__context_tag == to_underlying(Fields::kStartSystime))
        {
            err = DataModel::Decode(reader, startSystime);
        }
        else if (__context_tag == to_underlying(Fields::kEndSystime))
        {
            err = DataModel::Decode(reader, endSystime);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace EnergyMeasurementStruct
} // namespace Structs

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::Accuracy::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, accuracy);
    case Attributes::CumulativeEnergyImported::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, cumulativeEnergyImported);
    case Attributes::CumulativeEnergyExported::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, cumulativeEnergyExported);
    case Attributes::PeriodicEnergyImported::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, periodicEnergyImported);
    case Attributes::PeriodicEnergyExported::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, periodicEnergyExported);
    case Attributes::CumulativeEnergyReset::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, cumulativeEnergyReset);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace CumulativeEnergyMeasured {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kEnergyImported), energyImported));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kEnergyExported), energyExported));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kEnergyImported))
        {
            err = DataModel::Decode(reader, energyImported);
        }
        else if (__context_tag == to_underlying(Fields::kEnergyExported))
        {
            err = DataModel::Decode(reader, energyExported);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace CumulativeEnergyMeasured.
namespace PeriodicEnergyMeasured {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kEnergyImported), energyImported));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kEnergyExported), energyExported));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kEnergyImported))
        {
            err = DataModel::Decode(reader, energyImported);
        }
        else if (__context_tag == to_underlying(Fields::kEnergyExported))
        {
            err = DataModel::Decode(reader, energyExported);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace PeriodicEnergyMeasured.
} // namespace Events

} // namespace ElectricalEnergyMeasurement
namespace WaterHeaterManagement {
namespace Structs {

namespace WaterHeaterBoostInfoStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kDuration), duration);
    encoder.Encode(to_underlying(Fields::kOneShot), oneShot);
    encoder.Encode(to_underlying(Fields::kEmergencyBoost), emergencyBoost);
    encoder.Encode(to_underlying(Fields::kTemporarySetpoint), temporarySetpoint);
    encoder.Encode(to_underlying(Fields::kTargetPercentage), targetPercentage);
    encoder.Encode(to_underlying(Fields::kTargetReheat), targetReheat);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kDuration))
        {
            err = DataModel::Decode(reader, duration);
        }
        else if (__context_tag == to_underlying(Fields::kOneShot))
        {
            err = DataModel::Decode(reader, oneShot);
        }
        else if (__context_tag == to_underlying(Fields::kEmergencyBoost))
        {
            err = DataModel::Decode(reader, emergencyBoost);
        }
        else if (__context_tag == to_underlying(Fields::kTemporarySetpoint))
        {
            err = DataModel::Decode(reader, temporarySetpoint);
        }
        else if (__context_tag == to_underlying(Fields::kTargetPercentage))
        {
            err = DataModel::Decode(reader, targetPercentage);
        }
        else if (__context_tag == to_underlying(Fields::kTargetReheat))
        {
            err = DataModel::Decode(reader, targetReheat);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace WaterHeaterBoostInfoStruct
} // namespace Structs

namespace Commands {
namespace Boost {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kBoostInfo), boostInfo);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kBoostInfo))
        {
            err = DataModel::Decode(reader, boostInfo);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace Boost.
namespace CancelBoost {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace CancelBoost.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::HeaterTypes::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, heaterTypes);
    case Attributes::HeatDemand::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, heatDemand);
    case Attributes::TankVolume::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, tankVolume);
    case Attributes::EstimatedHeatRequired::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, estimatedHeatRequired);
    case Attributes::TankPercentage::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, tankPercentage);
    case Attributes::BoostState::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, boostState);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace BoostStarted {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kBoostInfo), boostInfo));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kBoostInfo))
        {
            err = DataModel::Decode(reader, boostInfo);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace BoostStarted.
namespace BoostEnded {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace BoostEnded.
} // namespace Events

} // namespace WaterHeaterManagement
namespace DemandResponseLoadControl {
namespace Structs {

namespace HeatingSourceControlStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kHeatingSource), heatingSource);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kHeatingSource))
        {
            err = DataModel::Decode(reader, heatingSource);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace HeatingSourceControlStruct

namespace PowerSavingsControlStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kPowerSavings), powerSavings);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kPowerSavings))
        {
            err = DataModel::Decode(reader, powerSavings);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace PowerSavingsControlStruct

namespace DutyCycleControlStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kDutyCycle), dutyCycle);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kDutyCycle))
        {
            err = DataModel::Decode(reader, dutyCycle);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace DutyCycleControlStruct

namespace AverageLoadControlStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kLoadAdjustment), loadAdjustment);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kLoadAdjustment))
        {
            err = DataModel::Decode(reader, loadAdjustment);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace AverageLoadControlStruct

namespace TemperatureControlStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kCoolingTempOffset), coolingTempOffset);
    encoder.Encode(to_underlying(Fields::kHeatingtTempOffset), heatingtTempOffset);
    encoder.Encode(to_underlying(Fields::kCoolingTempSetpoint), coolingTempSetpoint);
    encoder.Encode(to_underlying(Fields::kHeatingTempSetpoint), heatingTempSetpoint);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCoolingTempOffset))
        {
            err = DataModel::Decode(reader, coolingTempOffset);
        }
        else if (__context_tag == to_underlying(Fields::kHeatingtTempOffset))
        {
            err = DataModel::Decode(reader, heatingtTempOffset);
        }
        else if (__context_tag == to_underlying(Fields::kCoolingTempSetpoint))
        {
            err = DataModel::Decode(reader, coolingTempSetpoint);
        }
        else if (__context_tag == to_underlying(Fields::kHeatingTempSetpoint))
        {
            err = DataModel::Decode(reader, heatingTempSetpoint);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace TemperatureControlStruct

namespace LoadControlEventTransitionStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kDuration), duration);
    encoder.Encode(to_underlying(Fields::kControl), control);
    encoder.Encode(to_underlying(Fields::kTemperatureControl), temperatureControl);
    encoder.Encode(to_underlying(Fields::kAverageLoadControl), averageLoadControl);
    encoder.Encode(to_underlying(Fields::kDutyCycleControl), dutyCycleControl);
    encoder.Encode(to_underlying(Fields::kPowerSavingsControl), powerSavingsControl);
    encoder.Encode(to_underlying(Fields::kHeatingSourceControl), heatingSourceControl);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kDuration))
        {
            err = DataModel::Decode(reader, duration);
        }
        else if (__context_tag == to_underlying(Fields::kControl))
        {
            err = DataModel::Decode(reader, control);
        }
        else if (__context_tag == to_underlying(Fields::kTemperatureControl))
        {
            err = DataModel::Decode(reader, temperatureControl);
        }
        else if (__context_tag == to_underlying(Fields::kAverageLoadControl))
        {
            err = DataModel::Decode(reader, averageLoadControl);
        }
        else if (__context_tag == to_underlying(Fields::kDutyCycleControl))
        {
            err = DataModel::Decode(reader, dutyCycleControl);
        }
        else if (__context_tag == to_underlying(Fields::kPowerSavingsControl))
        {
            err = DataModel::Decode(reader, powerSavingsControl);
        }
        else if (__context_tag == to_underlying(Fields::kHeatingSourceControl))
        {
            err = DataModel::Decode(reader, heatingSourceControl);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace LoadControlEventTransitionStruct

namespace LoadControlEventStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kEventID), eventID);
    encoder.Encode(to_underlying(Fields::kProgramID), programID);
    encoder.Encode(to_underlying(Fields::kControl), control);
    encoder.Encode(to_underlying(Fields::kDeviceClass), deviceClass);
    encoder.Encode(to_underlying(Fields::kEnrollmentGroup), enrollmentGroup);
    encoder.Encode(to_underlying(Fields::kCriticality), criticality);
    encoder.Encode(to_underlying(Fields::kStartTime), startTime);
    encoder.Encode(to_underlying(Fields::kTransitions), transitions);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kEventID))
        {
            err = DataModel::Decode(reader, eventID);
        }
        else if (__context_tag == to_underlying(Fields::kProgramID))
        {
            err = DataModel::Decode(reader, programID);
        }
        else if (__context_tag == to_underlying(Fields::kControl))
        {
            err = DataModel::Decode(reader, control);
        }
        else if (__context_tag == to_underlying(Fields::kDeviceClass))
        {
            err = DataModel::Decode(reader, deviceClass);
        }
        else if (__context_tag == to_underlying(Fields::kEnrollmentGroup))
        {
            err = DataModel::Decode(reader, enrollmentGroup);
        }
        else if (__context_tag == to_underlying(Fields::kCriticality))
        {
            err = DataModel::Decode(reader, criticality);
        }
        else if (__context_tag == to_underlying(Fields::kStartTime))
        {
            err = DataModel::Decode(reader, startTime);
        }
        else if (__context_tag == to_underlying(Fields::kTransitions))
        {
            err = DataModel::Decode(reader, transitions);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace LoadControlEventStruct

namespace LoadControlProgramStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kProgramID), programID);
    encoder.Encode(to_underlying(Fields::kName), name);
    encoder.Encode(to_underlying(Fields::kEnrollmentGroup), enrollmentGroup);
    encoder.Encode(to_underlying(Fields::kRandomStartMinutes), randomStartMinutes);
    encoder.Encode(to_underlying(Fields::kRandomDurationMinutes), randomDurationMinutes);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kProgramID))
        {
            err = DataModel::Decode(reader, programID);
        }
        else if (__context_tag == to_underlying(Fields::kName))
        {
            err = DataModel::Decode(reader, name);
        }
        else if (__context_tag == to_underlying(Fields::kEnrollmentGroup))
        {
            err = DataModel::Decode(reader, enrollmentGroup);
        }
        else if (__context_tag == to_underlying(Fields::kRandomStartMinutes))
        {
            err = DataModel::Decode(reader, randomStartMinutes);
        }
        else if (__context_tag == to_underlying(Fields::kRandomDurationMinutes))
        {
            err = DataModel::Decode(reader, randomDurationMinutes);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace LoadControlProgramStruct
} // namespace Structs

namespace Commands {
namespace RegisterLoadControlProgramRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kLoadControlProgram), loadControlProgram);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kLoadControlProgram))
        {
            err = DataModel::Decode(reader, loadControlProgram);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace RegisterLoadControlProgramRequest.
namespace UnregisterLoadControlProgramRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kLoadControlProgramID), loadControlProgramID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kLoadControlProgramID))
        {
            err = DataModel::Decode(reader, loadControlProgramID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace UnregisterLoadControlProgramRequest.
namespace AddLoadControlEventRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kEvent), event);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kEvent))
        {
            err = DataModel::Decode(reader, event);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace AddLoadControlEventRequest.
namespace RemoveLoadControlEventRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kEventID), eventID);
    encoder.Encode(to_underlying(Fields::kCancelControl), cancelControl);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kEventID))
        {
            err = DataModel::Decode(reader, eventID);
        }
        else if (__context_tag == to_underlying(Fields::kCancelControl))
        {
            err = DataModel::Decode(reader, cancelControl);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace RemoveLoadControlEventRequest.
namespace ClearLoadControlEventsRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace ClearLoadControlEventsRequest.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::LoadControlPrograms::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, loadControlPrograms);
    case Attributes::NumberOfLoadControlPrograms::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, numberOfLoadControlPrograms);
    case Attributes::Events::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, events);
    case Attributes::ActiveEvents::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, activeEvents);
    case Attributes::NumberOfEventsPerProgram::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, numberOfEventsPerProgram);
    case Attributes::NumberOfTransitions::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, numberOfTransitions);
    case Attributes::DefaultRandomStart::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, defaultRandomStart);
    case Attributes::DefaultRandomDuration::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, defaultRandomDuration);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace LoadControlEventStatusChange {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kEventID), eventID));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kTransitionIndex), transitionIndex));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kStatus), status));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCriticality), criticality));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kControl), control));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kTemperatureControl), temperatureControl));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAverageLoadControl), averageLoadControl));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kDutyCycleControl), dutyCycleControl));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPowerSavingsControl), powerSavingsControl));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kHeatingSourceControl), heatingSourceControl));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kEventID))
        {
            err = DataModel::Decode(reader, eventID);
        }
        else if (__context_tag == to_underlying(Fields::kTransitionIndex))
        {
            err = DataModel::Decode(reader, transitionIndex);
        }
        else if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kCriticality))
        {
            err = DataModel::Decode(reader, criticality);
        }
        else if (__context_tag == to_underlying(Fields::kControl))
        {
            err = DataModel::Decode(reader, control);
        }
        else if (__context_tag == to_underlying(Fields::kTemperatureControl))
        {
            err = DataModel::Decode(reader, temperatureControl);
        }
        else if (__context_tag == to_underlying(Fields::kAverageLoadControl))
        {
            err = DataModel::Decode(reader, averageLoadControl);
        }
        else if (__context_tag == to_underlying(Fields::kDutyCycleControl))
        {
            err = DataModel::Decode(reader, dutyCycleControl);
        }
        else if (__context_tag == to_underlying(Fields::kPowerSavingsControl))
        {
            err = DataModel::Decode(reader, powerSavingsControl);
        }
        else if (__context_tag == to_underlying(Fields::kHeatingSourceControl))
        {
            err = DataModel::Decode(reader, heatingSourceControl);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace LoadControlEventStatusChange.
} // namespace Events

} // namespace DemandResponseLoadControl
namespace Messages {
namespace Structs {

namespace MessageResponseOptionStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kMessageResponseID), messageResponseID);
    encoder.Encode(to_underlying(Fields::kLabel), label);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kMessageResponseID))
        {
            err = DataModel::Decode(reader, messageResponseID);
        }
        else if (__context_tag == to_underlying(Fields::kLabel))
        {
            err = DataModel::Decode(reader, label);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace MessageResponseOptionStruct

namespace MessageStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kMessageID), messageID);
    encoder.Encode(to_underlying(Fields::kPriority), priority);
    encoder.Encode(to_underlying(Fields::kMessageControl), messageControl);
    encoder.Encode(to_underlying(Fields::kStartTime), startTime);
    encoder.Encode(to_underlying(Fields::kDuration), duration);
    encoder.Encode(to_underlying(Fields::kMessageText), messageText);
    encoder.Encode(to_underlying(Fields::kResponses), responses);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kMessageID))
        {
            err = DataModel::Decode(reader, messageID);
        }
        else if (__context_tag == to_underlying(Fields::kPriority))
        {
            err = DataModel::Decode(reader, priority);
        }
        else if (__context_tag == to_underlying(Fields::kMessageControl))
        {
            err = DataModel::Decode(reader, messageControl);
        }
        else if (__context_tag == to_underlying(Fields::kStartTime))
        {
            err = DataModel::Decode(reader, startTime);
        }
        else if (__context_tag == to_underlying(Fields::kDuration))
        {
            err = DataModel::Decode(reader, duration);
        }
        else if (__context_tag == to_underlying(Fields::kMessageText))
        {
            err = DataModel::Decode(reader, messageText);
        }
        else if (__context_tag == to_underlying(Fields::kResponses))
        {
            err = DataModel::Decode(reader, responses);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace MessageStruct
} // namespace Structs

namespace Commands {
namespace PresentMessagesRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kMessageID), messageID);
    encoder.Encode(to_underlying(Fields::kPriority), priority);
    encoder.Encode(to_underlying(Fields::kMessageControl), messageControl);
    encoder.Encode(to_underlying(Fields::kStartTime), startTime);
    encoder.Encode(to_underlying(Fields::kDuration), duration);
    encoder.Encode(to_underlying(Fields::kMessageText), messageText);
    encoder.Encode(to_underlying(Fields::kResponses), responses);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kMessageID))
        {
            err = DataModel::Decode(reader, messageID);
        }
        else if (__context_tag == to_underlying(Fields::kPriority))
        {
            err = DataModel::Decode(reader, priority);
        }
        else if (__context_tag == to_underlying(Fields::kMessageControl))
        {
            err = DataModel::Decode(reader, messageControl);
        }
        else if (__context_tag == to_underlying(Fields::kStartTime))
        {
            err = DataModel::Decode(reader, startTime);
        }
        else if (__context_tag == to_underlying(Fields::kDuration))
        {
            err = DataModel::Decode(reader, duration);
        }
        else if (__context_tag == to_underlying(Fields::kMessageText))
        {
            err = DataModel::Decode(reader, messageText);
        }
        else if (__context_tag == to_underlying(Fields::kResponses))
        {
            err = DataModel::Decode(reader, responses);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace PresentMessagesRequest.
namespace CancelMessagesRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kMessageIDs), messageIDs);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kMessageIDs))
        {
            err = DataModel::Decode(reader, messageIDs);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace CancelMessagesRequest.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::Messages::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, messages);
    case Attributes::ActiveMessageIDs::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, activeMessageIDs);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace MessageQueued {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMessageID), messageID));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kMessageID))
        {
            err = DataModel::Decode(reader, messageID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace MessageQueued.
namespace MessagePresented {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMessageID), messageID));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kMessageID))
        {
            err = DataModel::Decode(reader, messageID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace MessagePresented.
namespace MessageComplete {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMessageID), messageID));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kResponseID), responseID));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kReply), reply));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kFutureMessagesPreference), futureMessagesPreference));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kMessageID))
        {
            err = DataModel::Decode(reader, messageID);
        }
        else if (__context_tag == to_underlying(Fields::kResponseID))
        {
            err = DataModel::Decode(reader, responseID);
        }
        else if (__context_tag == to_underlying(Fields::kReply))
        {
            err = DataModel::Decode(reader, reply);
        }
        else if (__context_tag == to_underlying(Fields::kFutureMessagesPreference))
        {
            err = DataModel::Decode(reader, futureMessagesPreference);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace MessageComplete.
} // namespace Events

} // namespace Messages
namespace DeviceEnergyManagement {
namespace Structs {

namespace CostStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kCostType), costType);
    encoder.Encode(to_underlying(Fields::kValue), value);
    encoder.Encode(to_underlying(Fields::kDecimalPoints), decimalPoints);
    encoder.Encode(to_underlying(Fields::kCurrency), currency);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCostType))
        {
            err = DataModel::Decode(reader, costType);
        }
        else if (__context_tag == to_underlying(Fields::kValue))
        {
            err = DataModel::Decode(reader, value);
        }
        else if (__context_tag == to_underlying(Fields::kDecimalPoints))
        {
            err = DataModel::Decode(reader, decimalPoints);
        }
        else if (__context_tag == to_underlying(Fields::kCurrency))
        {
            err = DataModel::Decode(reader, currency);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace CostStruct

namespace PowerAdjustStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kMinPower), minPower);
    encoder.Encode(to_underlying(Fields::kMaxPower), maxPower);
    encoder.Encode(to_underlying(Fields::kMinDuration), minDuration);
    encoder.Encode(to_underlying(Fields::kMaxDuration), maxDuration);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kMinPower))
        {
            err = DataModel::Decode(reader, minPower);
        }
        else if (__context_tag == to_underlying(Fields::kMaxPower))
        {
            err = DataModel::Decode(reader, maxPower);
        }
        else if (__context_tag == to_underlying(Fields::kMinDuration))
        {
            err = DataModel::Decode(reader, minDuration);
        }
        else if (__context_tag == to_underlying(Fields::kMaxDuration))
        {
            err = DataModel::Decode(reader, maxDuration);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace PowerAdjustStruct

namespace PowerAdjustCapabilityStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kPowerAdjustCapability), powerAdjustCapability);
    encoder.Encode(to_underlying(Fields::kCause), cause);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kPowerAdjustCapability))
        {
            err = DataModel::Decode(reader, powerAdjustCapability);
        }
        else if (__context_tag == to_underlying(Fields::kCause))
        {
            err = DataModel::Decode(reader, cause);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace PowerAdjustCapabilityStruct

namespace SlotStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kMinDuration), minDuration);
    encoder.Encode(to_underlying(Fields::kMaxDuration), maxDuration);
    encoder.Encode(to_underlying(Fields::kDefaultDuration), defaultDuration);
    encoder.Encode(to_underlying(Fields::kElapsedSlotTime), elapsedSlotTime);
    encoder.Encode(to_underlying(Fields::kRemainingSlotTime), remainingSlotTime);
    encoder.Encode(to_underlying(Fields::kSlotIsPausable), slotIsPausable);
    encoder.Encode(to_underlying(Fields::kMinPauseDuration), minPauseDuration);
    encoder.Encode(to_underlying(Fields::kMaxPauseDuration), maxPauseDuration);
    encoder.Encode(to_underlying(Fields::kManufacturerESAState), manufacturerESAState);
    encoder.Encode(to_underlying(Fields::kNominalPower), nominalPower);
    encoder.Encode(to_underlying(Fields::kMinPower), minPower);
    encoder.Encode(to_underlying(Fields::kMaxPower), maxPower);
    encoder.Encode(to_underlying(Fields::kNominalEnergy), nominalEnergy);
    encoder.Encode(to_underlying(Fields::kCosts), costs);
    encoder.Encode(to_underlying(Fields::kMinPowerAdjustment), minPowerAdjustment);
    encoder.Encode(to_underlying(Fields::kMaxPowerAdjustment), maxPowerAdjustment);
    encoder.Encode(to_underlying(Fields::kMinDurationAdjustment), minDurationAdjustment);
    encoder.Encode(to_underlying(Fields::kMaxDurationAdjustment), maxDurationAdjustment);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kMinDuration))
        {
            err = DataModel::Decode(reader, minDuration);
        }
        else if (__context_tag == to_underlying(Fields::kMaxDuration))
        {
            err = DataModel::Decode(reader, maxDuration);
        }
        else if (__context_tag == to_underlying(Fields::kDefaultDuration))
        {
            err = DataModel::Decode(reader, defaultDuration);
        }
        else if (__context_tag == to_underlying(Fields::kElapsedSlotTime))
        {
            err = DataModel::Decode(reader, elapsedSlotTime);
        }
        else if (__context_tag == to_underlying(Fields::kRemainingSlotTime))
        {
            err = DataModel::Decode(reader, remainingSlotTime);
        }
        else if (__context_tag == to_underlying(Fields::kSlotIsPausable))
        {
            err = DataModel::Decode(reader, slotIsPausable);
        }
        else if (__context_tag == to_underlying(Fields::kMinPauseDuration))
        {
            err = DataModel::Decode(reader, minPauseDuration);
        }
        else if (__context_tag == to_underlying(Fields::kMaxPauseDuration))
        {
            err = DataModel::Decode(reader, maxPauseDuration);
        }
        else if (__context_tag == to_underlying(Fields::kManufacturerESAState))
        {
            err = DataModel::Decode(reader, manufacturerESAState);
        }
        else if (__context_tag == to_underlying(Fields::kNominalPower))
        {
            err = DataModel::Decode(reader, nominalPower);
        }
        else if (__context_tag == to_underlying(Fields::kMinPower))
        {
            err = DataModel::Decode(reader, minPower);
        }
        else if (__context_tag == to_underlying(Fields::kMaxPower))
        {
            err = DataModel::Decode(reader, maxPower);
        }
        else if (__context_tag == to_underlying(Fields::kNominalEnergy))
        {
            err = DataModel::Decode(reader, nominalEnergy);
        }
        else if (__context_tag == to_underlying(Fields::kCosts))
        {
            err = DataModel::Decode(reader, costs);
        }
        else if (__context_tag == to_underlying(Fields::kMinPowerAdjustment))
        {
            err = DataModel::Decode(reader, minPowerAdjustment);
        }
        else if (__context_tag == to_underlying(Fields::kMaxPowerAdjustment))
        {
            err = DataModel::Decode(reader, maxPowerAdjustment);
        }
        else if (__context_tag == to_underlying(Fields::kMinDurationAdjustment))
        {
            err = DataModel::Decode(reader, minDurationAdjustment);
        }
        else if (__context_tag == to_underlying(Fields::kMaxDurationAdjustment))
        {
            err = DataModel::Decode(reader, maxDurationAdjustment);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace SlotStruct

namespace ForecastStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kForecastID), forecastID);
    encoder.Encode(to_underlying(Fields::kActiveSlotNumber), activeSlotNumber);
    encoder.Encode(to_underlying(Fields::kStartTime), startTime);
    encoder.Encode(to_underlying(Fields::kEndTime), endTime);
    encoder.Encode(to_underlying(Fields::kEarliestStartTime), earliestStartTime);
    encoder.Encode(to_underlying(Fields::kLatestEndTime), latestEndTime);
    encoder.Encode(to_underlying(Fields::kIsPausable), isPausable);
    encoder.Encode(to_underlying(Fields::kSlots), slots);
    encoder.Encode(to_underlying(Fields::kForecastUpdateReason), forecastUpdateReason);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kForecastID))
        {
            err = DataModel::Decode(reader, forecastID);
        }
        else if (__context_tag == to_underlying(Fields::kActiveSlotNumber))
        {
            err = DataModel::Decode(reader, activeSlotNumber);
        }
        else if (__context_tag == to_underlying(Fields::kStartTime))
        {
            err = DataModel::Decode(reader, startTime);
        }
        else if (__context_tag == to_underlying(Fields::kEndTime))
        {
            err = DataModel::Decode(reader, endTime);
        }
        else if (__context_tag == to_underlying(Fields::kEarliestStartTime))
        {
            err = DataModel::Decode(reader, earliestStartTime);
        }
        else if (__context_tag == to_underlying(Fields::kLatestEndTime))
        {
            err = DataModel::Decode(reader, latestEndTime);
        }
        else if (__context_tag == to_underlying(Fields::kIsPausable))
        {
            err = DataModel::Decode(reader, isPausable);
        }
        else if (__context_tag == to_underlying(Fields::kSlots))
        {
            err = DataModel::Decode(reader, slots);
        }
        else if (__context_tag == to_underlying(Fields::kForecastUpdateReason))
        {
            err = DataModel::Decode(reader, forecastUpdateReason);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ForecastStruct

namespace ConstraintsStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStartTime), startTime);
    encoder.Encode(to_underlying(Fields::kDuration), duration);
    encoder.Encode(to_underlying(Fields::kNominalPower), nominalPower);
    encoder.Encode(to_underlying(Fields::kMaximumEnergy), maximumEnergy);
    encoder.Encode(to_underlying(Fields::kLoadControl), loadControl);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStartTime))
        {
            err = DataModel::Decode(reader, startTime);
        }
        else if (__context_tag == to_underlying(Fields::kDuration))
        {
            err = DataModel::Decode(reader, duration);
        }
        else if (__context_tag == to_underlying(Fields::kNominalPower))
        {
            err = DataModel::Decode(reader, nominalPower);
        }
        else if (__context_tag == to_underlying(Fields::kMaximumEnergy))
        {
            err = DataModel::Decode(reader, maximumEnergy);
        }
        else if (__context_tag == to_underlying(Fields::kLoadControl))
        {
            err = DataModel::Decode(reader, loadControl);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ConstraintsStruct

namespace SlotAdjustmentStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kSlotIndex), slotIndex);
    encoder.Encode(to_underlying(Fields::kNominalPower), nominalPower);
    encoder.Encode(to_underlying(Fields::kDuration), duration);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kSlotIndex))
        {
            err = DataModel::Decode(reader, slotIndex);
        }
        else if (__context_tag == to_underlying(Fields::kNominalPower))
        {
            err = DataModel::Decode(reader, nominalPower);
        }
        else if (__context_tag == to_underlying(Fields::kDuration))
        {
            err = DataModel::Decode(reader, duration);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace SlotAdjustmentStruct
} // namespace Structs

namespace Commands {
namespace PowerAdjustRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kPower), power);
    encoder.Encode(to_underlying(Fields::kDuration), duration);
    encoder.Encode(to_underlying(Fields::kCause), cause);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kPower))
        {
            err = DataModel::Decode(reader, power);
        }
        else if (__context_tag == to_underlying(Fields::kDuration))
        {
            err = DataModel::Decode(reader, duration);
        }
        else if (__context_tag == to_underlying(Fields::kCause))
        {
            err = DataModel::Decode(reader, cause);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace PowerAdjustRequest.
namespace CancelPowerAdjustRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace CancelPowerAdjustRequest.
namespace StartTimeAdjustRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kRequestedStartTime), requestedStartTime);
    encoder.Encode(to_underlying(Fields::kCause), cause);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kRequestedStartTime))
        {
            err = DataModel::Decode(reader, requestedStartTime);
        }
        else if (__context_tag == to_underlying(Fields::kCause))
        {
            err = DataModel::Decode(reader, cause);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace StartTimeAdjustRequest.
namespace PauseRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kDuration), duration);
    encoder.Encode(to_underlying(Fields::kCause), cause);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kDuration))
        {
            err = DataModel::Decode(reader, duration);
        }
        else if (__context_tag == to_underlying(Fields::kCause))
        {
            err = DataModel::Decode(reader, cause);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace PauseRequest.
namespace ResumeRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace ResumeRequest.
namespace ModifyForecastRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kForecastID), forecastID);
    encoder.Encode(to_underlying(Fields::kSlotAdjustments), slotAdjustments);
    encoder.Encode(to_underlying(Fields::kCause), cause);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kForecastID))
        {
            err = DataModel::Decode(reader, forecastID);
        }
        else if (__context_tag == to_underlying(Fields::kSlotAdjustments))
        {
            err = DataModel::Decode(reader, slotAdjustments);
        }
        else if (__context_tag == to_underlying(Fields::kCause))
        {
            err = DataModel::Decode(reader, cause);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ModifyForecastRequest.
namespace RequestConstraintBasedForecast {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kConstraints), constraints);
    encoder.Encode(to_underlying(Fields::kCause), cause);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kConstraints))
        {
            err = DataModel::Decode(reader, constraints);
        }
        else if (__context_tag == to_underlying(Fields::kCause))
        {
            err = DataModel::Decode(reader, cause);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace RequestConstraintBasedForecast.
namespace CancelRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace CancelRequest.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::ESAType::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, ESAType);
    case Attributes::ESACanGenerate::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, ESACanGenerate);
    case Attributes::ESAState::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, ESAState);
    case Attributes::AbsMinPower::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, absMinPower);
    case Attributes::AbsMaxPower::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, absMaxPower);
    case Attributes::PowerAdjustmentCapability::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, powerAdjustmentCapability);
    case Attributes::Forecast::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, forecast);
    case Attributes::OptOutState::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, optOutState);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace PowerAdjustStart {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace PowerAdjustStart.
namespace PowerAdjustEnd {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCause), cause));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kDuration), duration));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kEnergyUse), energyUse));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCause))
        {
            err = DataModel::Decode(reader, cause);
        }
        else if (__context_tag == to_underlying(Fields::kDuration))
        {
            err = DataModel::Decode(reader, duration);
        }
        else if (__context_tag == to_underlying(Fields::kEnergyUse))
        {
            err = DataModel::Decode(reader, energyUse);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace PowerAdjustEnd.
namespace Paused {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace Paused.
namespace Resumed {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCause), cause));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCause))
        {
            err = DataModel::Decode(reader, cause);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace Resumed.
} // namespace Events

} // namespace DeviceEnergyManagement
namespace EnergyEvse {
namespace Structs {

namespace ChargingTargetStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kTargetTimeMinutesPastMidnight), targetTimeMinutesPastMidnight);
    encoder.Encode(to_underlying(Fields::kTargetSoC), targetSoC);
    encoder.Encode(to_underlying(Fields::kAddedEnergy), addedEnergy);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kTargetTimeMinutesPastMidnight))
        {
            err = DataModel::Decode(reader, targetTimeMinutesPastMidnight);
        }
        else if (__context_tag == to_underlying(Fields::kTargetSoC))
        {
            err = DataModel::Decode(reader, targetSoC);
        }
        else if (__context_tag == to_underlying(Fields::kAddedEnergy))
        {
            err = DataModel::Decode(reader, addedEnergy);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ChargingTargetStruct

namespace ChargingTargetScheduleStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kDayOfWeekForSequence), dayOfWeekForSequence);
    encoder.Encode(to_underlying(Fields::kChargingTargets), chargingTargets);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kDayOfWeekForSequence))
        {
            err = DataModel::Decode(reader, dayOfWeekForSequence);
        }
        else if (__context_tag == to_underlying(Fields::kChargingTargets))
        {
            err = DataModel::Decode(reader, chargingTargets);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ChargingTargetScheduleStruct
} // namespace Structs

namespace Commands {
namespace GetTargetsResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kChargingTargetSchedules), chargingTargetSchedules);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kChargingTargetSchedules))
        {
            err = DataModel::Decode(reader, chargingTargetSchedules);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GetTargetsResponse.
namespace Disable {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace Disable.
namespace EnableCharging {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kChargingEnabledUntil), chargingEnabledUntil);
    encoder.Encode(to_underlying(Fields::kMinimumChargeCurrent), minimumChargeCurrent);
    encoder.Encode(to_underlying(Fields::kMaximumChargeCurrent), maximumChargeCurrent);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kChargingEnabledUntil))
        {
            err = DataModel::Decode(reader, chargingEnabledUntil);
        }
        else if (__context_tag == to_underlying(Fields::kMinimumChargeCurrent))
        {
            err = DataModel::Decode(reader, minimumChargeCurrent);
        }
        else if (__context_tag == to_underlying(Fields::kMaximumChargeCurrent))
        {
            err = DataModel::Decode(reader, maximumChargeCurrent);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace EnableCharging.
namespace EnableDischarging {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kDischargingEnabledUntil), dischargingEnabledUntil);
    encoder.Encode(to_underlying(Fields::kMaximumDischargeCurrent), maximumDischargeCurrent);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kDischargingEnabledUntil))
        {
            err = DataModel::Decode(reader, dischargingEnabledUntil);
        }
        else if (__context_tag == to_underlying(Fields::kMaximumDischargeCurrent))
        {
            err = DataModel::Decode(reader, maximumDischargeCurrent);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace EnableDischarging.
namespace StartDiagnostics {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace StartDiagnostics.
namespace SetTargets {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kChargingTargetSchedules), chargingTargetSchedules);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kChargingTargetSchedules))
        {
            err = DataModel::Decode(reader, chargingTargetSchedules);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetTargets.
namespace GetTargets {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace GetTargets.
namespace ClearTargets {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace ClearTargets.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::State::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, state);
    case Attributes::SupplyState::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, supplyState);
    case Attributes::FaultState::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, faultState);
    case Attributes::ChargingEnabledUntil::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, chargingEnabledUntil);
    case Attributes::DischargingEnabledUntil::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, dischargingEnabledUntil);
    case Attributes::CircuitCapacity::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, circuitCapacity);
    case Attributes::MinimumChargeCurrent::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, minimumChargeCurrent);
    case Attributes::MaximumChargeCurrent::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maximumChargeCurrent);
    case Attributes::MaximumDischargeCurrent::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maximumDischargeCurrent);
    case Attributes::UserMaximumChargeCurrent::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, userMaximumChargeCurrent);
    case Attributes::RandomizationDelayWindow::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, randomizationDelayWindow);
    case Attributes::NextChargeStartTime::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nextChargeStartTime);
    case Attributes::NextChargeTargetTime::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nextChargeTargetTime);
    case Attributes::NextChargeRequiredEnergy::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nextChargeRequiredEnergy);
    case Attributes::NextChargeTargetSoC::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nextChargeTargetSoC);
    case Attributes::ApproximateEVEfficiency::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, approximateEVEfficiency);
    case Attributes::StateOfCharge::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, stateOfCharge);
    case Attributes::BatteryCapacity::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, batteryCapacity);
    case Attributes::VehicleID::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, vehicleID);
    case Attributes::SessionID::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, sessionID);
    case Attributes::SessionDuration::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, sessionDuration);
    case Attributes::SessionEnergyCharged::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, sessionEnergyCharged);
    case Attributes::SessionEnergyDischarged::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, sessionEnergyDischarged);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace EVConnected {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSessionID), sessionID));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kSessionID))
        {
            err = DataModel::Decode(reader, sessionID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace EVConnected.
namespace EVNotDetected {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSessionID), sessionID));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kState), state));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSessionDuration), sessionDuration));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSessionEnergyCharged), sessionEnergyCharged));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSessionEnergyDischarged), sessionEnergyDischarged));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kSessionID))
        {
            err = DataModel::Decode(reader, sessionID);
        }
        else if (__context_tag == to_underlying(Fields::kState))
        {
            err = DataModel::Decode(reader, state);
        }
        else if (__context_tag == to_underlying(Fields::kSessionDuration))
        {
            err = DataModel::Decode(reader, sessionDuration);
        }
        else if (__context_tag == to_underlying(Fields::kSessionEnergyCharged))
        {
            err = DataModel::Decode(reader, sessionEnergyCharged);
        }
        else if (__context_tag == to_underlying(Fields::kSessionEnergyDischarged))
        {
            err = DataModel::Decode(reader, sessionEnergyDischarged);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace EVNotDetected.
namespace EnergyTransferStarted {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSessionID), sessionID));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kState), state));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMaximumCurrent), maximumCurrent));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMaximumDischargeCurrent), maximumDischargeCurrent));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kSessionID))
        {
            err = DataModel::Decode(reader, sessionID);
        }
        else if (__context_tag == to_underlying(Fields::kState))
        {
            err = DataModel::Decode(reader, state);
        }
        else if (__context_tag == to_underlying(Fields::kMaximumCurrent))
        {
            err = DataModel::Decode(reader, maximumCurrent);
        }
        else if (__context_tag == to_underlying(Fields::kMaximumDischargeCurrent))
        {
            err = DataModel::Decode(reader, maximumDischargeCurrent);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace EnergyTransferStarted.
namespace EnergyTransferStopped {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSessionID), sessionID));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kState), state));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kReason), reason));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kEnergyTransferred), energyTransferred));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kEnergyDischarged), energyDischarged));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kSessionID))
        {
            err = DataModel::Decode(reader, sessionID);
        }
        else if (__context_tag == to_underlying(Fields::kState))
        {
            err = DataModel::Decode(reader, state);
        }
        else if (__context_tag == to_underlying(Fields::kReason))
        {
            err = DataModel::Decode(reader, reason);
        }
        else if (__context_tag == to_underlying(Fields::kEnergyTransferred))
        {
            err = DataModel::Decode(reader, energyTransferred);
        }
        else if (__context_tag == to_underlying(Fields::kEnergyDischarged))
        {
            err = DataModel::Decode(reader, energyDischarged);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace EnergyTransferStopped.
namespace Fault {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSessionID), sessionID));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kState), state));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kFaultStatePreviousState), faultStatePreviousState));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kFaultStateCurrentState), faultStateCurrentState));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kSessionID))
        {
            err = DataModel::Decode(reader, sessionID);
        }
        else if (__context_tag == to_underlying(Fields::kState))
        {
            err = DataModel::Decode(reader, state);
        }
        else if (__context_tag == to_underlying(Fields::kFaultStatePreviousState))
        {
            err = DataModel::Decode(reader, faultStatePreviousState);
        }
        else if (__context_tag == to_underlying(Fields::kFaultStateCurrentState))
        {
            err = DataModel::Decode(reader, faultStateCurrentState);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace Fault.
namespace Rfid {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kUid), uid));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kUid))
        {
            err = DataModel::Decode(reader, uid);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace Rfid.
} // namespace Events

} // namespace EnergyEvse
namespace EnergyPreference {
namespace Structs {

namespace BalanceStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStep), step);
    encoder.Encode(to_underlying(Fields::kLabel), label);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStep))
        {
            err = DataModel::Decode(reader, step);
        }
        else if (__context_tag == to_underlying(Fields::kLabel))
        {
            err = DataModel::Decode(reader, label);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace BalanceStruct
} // namespace Structs

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::EnergyBalances::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, energyBalances);
    case Attributes::CurrentEnergyBalance::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentEnergyBalance);
    case Attributes::EnergyPriorities::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, energyPriorities);
    case Attributes::LowPowerModeSensitivities::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, lowPowerModeSensitivities);
    case Attributes::CurrentLowPowerModeSensitivity::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentLowPowerModeSensitivity);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace EnergyPreference
namespace PowerTopology {

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::AvailableEndpoints::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, availableEndpoints);
    case Attributes::ActiveEndpoints::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, activeEndpoints);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace PowerTopology
namespace EnergyEvseMode {
namespace Structs {} // namespace Structs

namespace Commands {
namespace ChangeToMode {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kNewMode), newMode);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNewMode))
        {
            err = DataModel::Decode(reader, newMode);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ChangeToMode.
namespace ChangeToModeResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kStatusText), statusText);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kStatusText))
        {
            err = DataModel::Decode(reader, statusText);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ChangeToModeResponse.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::SupportedModes::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, supportedModes);
    case Attributes::CurrentMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentMode);
    case Attributes::StartUpMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, startUpMode);
    case Attributes::OnMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, onMode);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace EnergyEvseMode
namespace WaterHeaterMode {
namespace Structs {} // namespace Structs

namespace Commands {
namespace ChangeToMode {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kNewMode), newMode);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNewMode))
        {
            err = DataModel::Decode(reader, newMode);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ChangeToMode.
namespace ChangeToModeResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kStatusText), statusText);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kStatusText))
        {
            err = DataModel::Decode(reader, statusText);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ChangeToModeResponse.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::SupportedModes::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, supportedModes);
    case Attributes::CurrentMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentMode);
    case Attributes::StartUpMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, startUpMode);
    case Attributes::OnMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, onMode);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace WaterHeaterMode
namespace DeviceEnergyManagementMode {
namespace Structs {} // namespace Structs

namespace Commands {
namespace ChangeToMode {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kNewMode), newMode);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNewMode))
        {
            err = DataModel::Decode(reader, newMode);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ChangeToMode.
namespace ChangeToModeResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kStatusText), statusText);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kStatusText))
        {
            err = DataModel::Decode(reader, statusText);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ChangeToModeResponse.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::SupportedModes::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, supportedModes);
    case Attributes::CurrentMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentMode);
    case Attributes::StartUpMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, startUpMode);
    case Attributes::OnMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, onMode);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace DeviceEnergyManagementMode
namespace DoorLock {
namespace Structs {

namespace CredentialStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kCredentialType), credentialType);
    encoder.Encode(to_underlying(Fields::kCredentialIndex), credentialIndex);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCredentialType))
        {
            err = DataModel::Decode(reader, credentialType);
        }
        else if (__context_tag == to_underlying(Fields::kCredentialIndex))
        {
            err = DataModel::Decode(reader, credentialIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace CredentialStruct
} // namespace Structs

namespace Commands {
namespace LockDoor {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kPINCode), PINCode);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kPINCode))
        {
            err = DataModel::Decode(reader, PINCode);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace LockDoor.
namespace UnlockDoor {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kPINCode), PINCode);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kPINCode))
        {
            err = DataModel::Decode(reader, PINCode);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace UnlockDoor.
namespace UnlockWithTimeout {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kTimeout), timeout);
    encoder.Encode(to_underlying(Fields::kPINCode), PINCode);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kTimeout))
        {
            err = DataModel::Decode(reader, timeout);
        }
        else if (__context_tag == to_underlying(Fields::kPINCode))
        {
            err = DataModel::Decode(reader, PINCode);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace UnlockWithTimeout.
namespace SetWeekDaySchedule {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kWeekDayIndex), weekDayIndex);
    encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
    encoder.Encode(to_underlying(Fields::kDaysMask), daysMask);
    encoder.Encode(to_underlying(Fields::kStartHour), startHour);
    encoder.Encode(to_underlying(Fields::kStartMinute), startMinute);
    encoder.Encode(to_underlying(Fields::kEndHour), endHour);
    encoder.Encode(to_underlying(Fields::kEndMinute), endMinute);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kWeekDayIndex))
        {
            err = DataModel::Decode(reader, weekDayIndex);
        }
        else if (__context_tag == to_underlying(Fields::kUserIndex))
        {
            err = DataModel::Decode(reader, userIndex);
        }
        else if (__context_tag == to_underlying(Fields::kDaysMask))
        {
            err = DataModel::Decode(reader, daysMask);
        }
        else if (__context_tag == to_underlying(Fields::kStartHour))
        {
            err = DataModel::Decode(reader, startHour);
        }
        else if (__context_tag == to_underlying(Fields::kStartMinute))
        {
            err = DataModel::Decode(reader, startMinute);
        }
        else if (__context_tag == to_underlying(Fields::kEndHour))
        {
            err = DataModel::Decode(reader, endHour);
        }
        else if (__context_tag == to_underlying(Fields::kEndMinute))
        {
            err = DataModel::Decode(reader, endMinute);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetWeekDaySchedule.
namespace GetWeekDaySchedule {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kWeekDayIndex), weekDayIndex);
    encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kWeekDayIndex))
        {
            err = DataModel::Decode(reader, weekDayIndex);
        }
        else if (__context_tag == to_underlying(Fields::kUserIndex))
        {
            err = DataModel::Decode(reader, userIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GetWeekDaySchedule.
namespace GetWeekDayScheduleResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kWeekDayIndex), weekDayIndex);
    encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kDaysMask), daysMask);
    encoder.Encode(to_underlying(Fields::kStartHour), startHour);
    encoder.Encode(to_underlying(Fields::kStartMinute), startMinute);
    encoder.Encode(to_underlying(Fields::kEndHour), endHour);
    encoder.Encode(to_underlying(Fields::kEndMinute), endMinute);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kWeekDayIndex))
        {
            err = DataModel::Decode(reader, weekDayIndex);
        }
        else if (__context_tag == to_underlying(Fields::kUserIndex))
        {
            err = DataModel::Decode(reader, userIndex);
        }
        else if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kDaysMask))
        {
            err = DataModel::Decode(reader, daysMask);
        }
        else if (__context_tag == to_underlying(Fields::kStartHour))
        {
            err = DataModel::Decode(reader, startHour);
        }
        else if (__context_tag == to_underlying(Fields::kStartMinute))
        {
            err = DataModel::Decode(reader, startMinute);
        }
        else if (__context_tag == to_underlying(Fields::kEndHour))
        {
            err = DataModel::Decode(reader, endHour);
        }
        else if (__context_tag == to_underlying(Fields::kEndMinute))
        {
            err = DataModel::Decode(reader, endMinute);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GetWeekDayScheduleResponse.
namespace ClearWeekDaySchedule {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kWeekDayIndex), weekDayIndex);
    encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kWeekDayIndex))
        {
            err = DataModel::Decode(reader, weekDayIndex);
        }
        else if (__context_tag == to_underlying(Fields::kUserIndex))
        {
            err = DataModel::Decode(reader, userIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ClearWeekDaySchedule.
namespace SetYearDaySchedule {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kYearDayIndex), yearDayIndex);
    encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
    encoder.Encode(to_underlying(Fields::kLocalStartTime), localStartTime);
    encoder.Encode(to_underlying(Fields::kLocalEndTime), localEndTime);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kYearDayIndex))
        {
            err = DataModel::Decode(reader, yearDayIndex);
        }
        else if (__context_tag == to_underlying(Fields::kUserIndex))
        {
            err = DataModel::Decode(reader, userIndex);
        }
        else if (__context_tag == to_underlying(Fields::kLocalStartTime))
        {
            err = DataModel::Decode(reader, localStartTime);
        }
        else if (__context_tag == to_underlying(Fields::kLocalEndTime))
        {
            err = DataModel::Decode(reader, localEndTime);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetYearDaySchedule.
namespace GetYearDaySchedule {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kYearDayIndex), yearDayIndex);
    encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kYearDayIndex))
        {
            err = DataModel::Decode(reader, yearDayIndex);
        }
        else if (__context_tag == to_underlying(Fields::kUserIndex))
        {
            err = DataModel::Decode(reader, userIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GetYearDaySchedule.
namespace GetYearDayScheduleResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kYearDayIndex), yearDayIndex);
    encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kLocalStartTime), localStartTime);
    encoder.Encode(to_underlying(Fields::kLocalEndTime), localEndTime);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kYearDayIndex))
        {
            err = DataModel::Decode(reader, yearDayIndex);
        }
        else if (__context_tag == to_underlying(Fields::kUserIndex))
        {
            err = DataModel::Decode(reader, userIndex);
        }
        else if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kLocalStartTime))
        {
            err = DataModel::Decode(reader, localStartTime);
        }
        else if (__context_tag == to_underlying(Fields::kLocalEndTime))
        {
            err = DataModel::Decode(reader, localEndTime);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GetYearDayScheduleResponse.
namespace ClearYearDaySchedule {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kYearDayIndex), yearDayIndex);
    encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kYearDayIndex))
        {
            err = DataModel::Decode(reader, yearDayIndex);
        }
        else if (__context_tag == to_underlying(Fields::kUserIndex))
        {
            err = DataModel::Decode(reader, userIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ClearYearDaySchedule.
namespace SetHolidaySchedule {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kHolidayIndex), holidayIndex);
    encoder.Encode(to_underlying(Fields::kLocalStartTime), localStartTime);
    encoder.Encode(to_underlying(Fields::kLocalEndTime), localEndTime);
    encoder.Encode(to_underlying(Fields::kOperatingMode), operatingMode);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kHolidayIndex))
        {
            err = DataModel::Decode(reader, holidayIndex);
        }
        else if (__context_tag == to_underlying(Fields::kLocalStartTime))
        {
            err = DataModel::Decode(reader, localStartTime);
        }
        else if (__context_tag == to_underlying(Fields::kLocalEndTime))
        {
            err = DataModel::Decode(reader, localEndTime);
        }
        else if (__context_tag == to_underlying(Fields::kOperatingMode))
        {
            err = DataModel::Decode(reader, operatingMode);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetHolidaySchedule.
namespace GetHolidaySchedule {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kHolidayIndex), holidayIndex);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kHolidayIndex))
        {
            err = DataModel::Decode(reader, holidayIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GetHolidaySchedule.
namespace GetHolidayScheduleResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kHolidayIndex), holidayIndex);
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kLocalStartTime), localStartTime);
    encoder.Encode(to_underlying(Fields::kLocalEndTime), localEndTime);
    encoder.Encode(to_underlying(Fields::kOperatingMode), operatingMode);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kHolidayIndex))
        {
            err = DataModel::Decode(reader, holidayIndex);
        }
        else if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kLocalStartTime))
        {
            err = DataModel::Decode(reader, localStartTime);
        }
        else if (__context_tag == to_underlying(Fields::kLocalEndTime))
        {
            err = DataModel::Decode(reader, localEndTime);
        }
        else if (__context_tag == to_underlying(Fields::kOperatingMode))
        {
            err = DataModel::Decode(reader, operatingMode);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GetHolidayScheduleResponse.
namespace ClearHolidaySchedule {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kHolidayIndex), holidayIndex);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kHolidayIndex))
        {
            err = DataModel::Decode(reader, holidayIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ClearHolidaySchedule.
namespace SetUser {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kOperationType), operationType);
    encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
    encoder.Encode(to_underlying(Fields::kUserName), userName);
    encoder.Encode(to_underlying(Fields::kUserUniqueID), userUniqueID);
    encoder.Encode(to_underlying(Fields::kUserStatus), userStatus);
    encoder.Encode(to_underlying(Fields::kUserType), userType);
    encoder.Encode(to_underlying(Fields::kCredentialRule), credentialRule);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kOperationType))
        {
            err = DataModel::Decode(reader, operationType);
        }
        else if (__context_tag == to_underlying(Fields::kUserIndex))
        {
            err = DataModel::Decode(reader, userIndex);
        }
        else if (__context_tag == to_underlying(Fields::kUserName))
        {
            err = DataModel::Decode(reader, userName);
        }
        else if (__context_tag == to_underlying(Fields::kUserUniqueID))
        {
            err = DataModel::Decode(reader, userUniqueID);
        }
        else if (__context_tag == to_underlying(Fields::kUserStatus))
        {
            err = DataModel::Decode(reader, userStatus);
        }
        else if (__context_tag == to_underlying(Fields::kUserType))
        {
            err = DataModel::Decode(reader, userType);
        }
        else if (__context_tag == to_underlying(Fields::kCredentialRule))
        {
            err = DataModel::Decode(reader, credentialRule);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetUser.
namespace GetUser {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kUserIndex))
        {
            err = DataModel::Decode(reader, userIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GetUser.
namespace GetUserResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
    encoder.Encode(to_underlying(Fields::kUserName), userName);
    encoder.Encode(to_underlying(Fields::kUserUniqueID), userUniqueID);
    encoder.Encode(to_underlying(Fields::kUserStatus), userStatus);
    encoder.Encode(to_underlying(Fields::kUserType), userType);
    encoder.Encode(to_underlying(Fields::kCredentialRule), credentialRule);
    encoder.Encode(to_underlying(Fields::kCredentials), credentials);
    encoder.Encode(to_underlying(Fields::kCreatorFabricIndex), creatorFabricIndex);
    encoder.Encode(to_underlying(Fields::kLastModifiedFabricIndex), lastModifiedFabricIndex);
    encoder.Encode(to_underlying(Fields::kNextUserIndex), nextUserIndex);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kUserIndex))
        {
            err = DataModel::Decode(reader, userIndex);
        }
        else if (__context_tag == to_underlying(Fields::kUserName))
        {
            err = DataModel::Decode(reader, userName);
        }
        else if (__context_tag == to_underlying(Fields::kUserUniqueID))
        {
            err = DataModel::Decode(reader, userUniqueID);
        }
        else if (__context_tag == to_underlying(Fields::kUserStatus))
        {
            err = DataModel::Decode(reader, userStatus);
        }
        else if (__context_tag == to_underlying(Fields::kUserType))
        {
            err = DataModel::Decode(reader, userType);
        }
        else if (__context_tag == to_underlying(Fields::kCredentialRule))
        {
            err = DataModel::Decode(reader, credentialRule);
        }
        else if (__context_tag == to_underlying(Fields::kCredentials))
        {
            err = DataModel::Decode(reader, credentials);
        }
        else if (__context_tag == to_underlying(Fields::kCreatorFabricIndex))
        {
            err = DataModel::Decode(reader, creatorFabricIndex);
        }
        else if (__context_tag == to_underlying(Fields::kLastModifiedFabricIndex))
        {
            err = DataModel::Decode(reader, lastModifiedFabricIndex);
        }
        else if (__context_tag == to_underlying(Fields::kNextUserIndex))
        {
            err = DataModel::Decode(reader, nextUserIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GetUserResponse.
namespace ClearUser {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kUserIndex))
        {
            err = DataModel::Decode(reader, userIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ClearUser.
namespace SetCredential {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kOperationType), operationType);
    encoder.Encode(to_underlying(Fields::kCredential), credential);
    encoder.Encode(to_underlying(Fields::kCredentialData), credentialData);
    encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
    encoder.Encode(to_underlying(Fields::kUserStatus), userStatus);
    encoder.Encode(to_underlying(Fields::kUserType), userType);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kOperationType))
        {
            err = DataModel::Decode(reader, operationType);
        }
        else if (__context_tag == to_underlying(Fields::kCredential))
        {
            err = DataModel::Decode(reader, credential);
        }
        else if (__context_tag == to_underlying(Fields::kCredentialData))
        {
            err = DataModel::Decode(reader, credentialData);
        }
        else if (__context_tag == to_underlying(Fields::kUserIndex))
        {
            err = DataModel::Decode(reader, userIndex);
        }
        else if (__context_tag == to_underlying(Fields::kUserStatus))
        {
            err = DataModel::Decode(reader, userStatus);
        }
        else if (__context_tag == to_underlying(Fields::kUserType))
        {
            err = DataModel::Decode(reader, userType);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetCredential.
namespace SetCredentialResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
    encoder.Encode(to_underlying(Fields::kNextCredentialIndex), nextCredentialIndex);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kUserIndex))
        {
            err = DataModel::Decode(reader, userIndex);
        }
        else if (__context_tag == to_underlying(Fields::kNextCredentialIndex))
        {
            err = DataModel::Decode(reader, nextCredentialIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetCredentialResponse.
namespace GetCredentialStatus {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kCredential), credential);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCredential))
        {
            err = DataModel::Decode(reader, credential);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GetCredentialStatus.
namespace GetCredentialStatusResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kCredentialExists), credentialExists);
    encoder.Encode(to_underlying(Fields::kUserIndex), userIndex);
    encoder.Encode(to_underlying(Fields::kCreatorFabricIndex), creatorFabricIndex);
    encoder.Encode(to_underlying(Fields::kLastModifiedFabricIndex), lastModifiedFabricIndex);
    encoder.Encode(to_underlying(Fields::kNextCredentialIndex), nextCredentialIndex);
    encoder.Encode(to_underlying(Fields::kCredentialData), credentialData);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCredentialExists))
        {
            err = DataModel::Decode(reader, credentialExists);
        }
        else if (__context_tag == to_underlying(Fields::kUserIndex))
        {
            err = DataModel::Decode(reader, userIndex);
        }
        else if (__context_tag == to_underlying(Fields::kCreatorFabricIndex))
        {
            err = DataModel::Decode(reader, creatorFabricIndex);
        }
        else if (__context_tag == to_underlying(Fields::kLastModifiedFabricIndex))
        {
            err = DataModel::Decode(reader, lastModifiedFabricIndex);
        }
        else if (__context_tag == to_underlying(Fields::kNextCredentialIndex))
        {
            err = DataModel::Decode(reader, nextCredentialIndex);
        }
        else if (__context_tag == to_underlying(Fields::kCredentialData))
        {
            err = DataModel::Decode(reader, credentialData);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GetCredentialStatusResponse.
namespace ClearCredential {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kCredential), credential);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCredential))
        {
            err = DataModel::Decode(reader, credential);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ClearCredential.
namespace UnboltDoor {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kPINCode), PINCode);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kPINCode))
        {
            err = DataModel::Decode(reader, PINCode);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace UnboltDoor.
namespace SetAliroReaderConfig {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kSigningKey), signingKey);
    encoder.Encode(to_underlying(Fields::kVerificationKey), verificationKey);
    encoder.Encode(to_underlying(Fields::kGroupIdentifier), groupIdentifier);
    encoder.Encode(to_underlying(Fields::kGroupResolvingKey), groupResolvingKey);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kSigningKey))
        {
            err = DataModel::Decode(reader, signingKey);
        }
        else if (__context_tag == to_underlying(Fields::kVerificationKey))
        {
            err = DataModel::Decode(reader, verificationKey);
        }
        else if (__context_tag == to_underlying(Fields::kGroupIdentifier))
        {
            err = DataModel::Decode(reader, groupIdentifier);
        }
        else if (__context_tag == to_underlying(Fields::kGroupResolvingKey))
        {
            err = DataModel::Decode(reader, groupResolvingKey);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetAliroReaderConfig.
namespace ClearAliroReaderConfig {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace ClearAliroReaderConfig.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::LockState::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, lockState);
    case Attributes::LockType::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, lockType);
    case Attributes::ActuatorEnabled::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, actuatorEnabled);
    case Attributes::DoorState::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, doorState);
    case Attributes::DoorOpenEvents::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, doorOpenEvents);
    case Attributes::DoorClosedEvents::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, doorClosedEvents);
    case Attributes::OpenPeriod::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, openPeriod);
    case Attributes::NumberOfTotalUsersSupported::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, numberOfTotalUsersSupported);
    case Attributes::NumberOfPINUsersSupported::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, numberOfPINUsersSupported);
    case Attributes::NumberOfRFIDUsersSupported::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, numberOfRFIDUsersSupported);
    case Attributes::NumberOfWeekDaySchedulesSupportedPerUser::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, numberOfWeekDaySchedulesSupportedPerUser);
    case Attributes::NumberOfYearDaySchedulesSupportedPerUser::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, numberOfYearDaySchedulesSupportedPerUser);
    case Attributes::NumberOfHolidaySchedulesSupported::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, numberOfHolidaySchedulesSupported);
    case Attributes::MaxPINCodeLength::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxPINCodeLength);
    case Attributes::MinPINCodeLength::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, minPINCodeLength);
    case Attributes::MaxRFIDCodeLength::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxRFIDCodeLength);
    case Attributes::MinRFIDCodeLength::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, minRFIDCodeLength);
    case Attributes::CredentialRulesSupport::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, credentialRulesSupport);
    case Attributes::NumberOfCredentialsSupportedPerUser::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, numberOfCredentialsSupportedPerUser);
    case Attributes::Language::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, language);
    case Attributes::LEDSettings::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, LEDSettings);
    case Attributes::AutoRelockTime::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, autoRelockTime);
    case Attributes::SoundVolume::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, soundVolume);
    case Attributes::OperatingMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, operatingMode);
    case Attributes::SupportedOperatingModes::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, supportedOperatingModes);
    case Attributes::DefaultConfigurationRegister::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, defaultConfigurationRegister);
    case Attributes::EnableLocalProgramming::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, enableLocalProgramming);
    case Attributes::EnableOneTouchLocking::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, enableOneTouchLocking);
    case Attributes::EnableInsideStatusLED::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, enableInsideStatusLED);
    case Attributes::EnablePrivacyModeButton::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, enablePrivacyModeButton);
    case Attributes::LocalProgrammingFeatures::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, localProgrammingFeatures);
    case Attributes::WrongCodeEntryLimit::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, wrongCodeEntryLimit);
    case Attributes::UserCodeTemporaryDisableTime::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, userCodeTemporaryDisableTime);
    case Attributes::SendPINOverTheAir::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, sendPINOverTheAir);
    case Attributes::RequirePINforRemoteOperation::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, requirePINforRemoteOperation);
    case Attributes::ExpiringUserTimeout::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, expiringUserTimeout);
    case Attributes::AliroReaderVerificationKey::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, aliroReaderVerificationKey);
    case Attributes::AliroReaderGroupIdentifier::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, aliroReaderGroupIdentifier);
    case Attributes::AliroReaderGroupSubIdentifier::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, aliroReaderGroupSubIdentifier);
    case Attributes::AliroExpeditedTransactionSupportedProtocolVersions::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, aliroExpeditedTransactionSupportedProtocolVersions);
    case Attributes::AliroGroupResolvingKey::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, aliroGroupResolvingKey);
    case Attributes::AliroSupportedBLEUWBProtocolVersions::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, aliroSupportedBLEUWBProtocolVersions);
    case Attributes::AliroBLEAdvertisingVersion::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, aliroBLEAdvertisingVersion);
    case Attributes::NumberOfAliroCredentialIssuerKeysSupported::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, numberOfAliroCredentialIssuerKeysSupported);
    case Attributes::NumberOfAliroEndpointKeysSupported::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, numberOfAliroEndpointKeysSupported);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace DoorLockAlarm {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAlarmCode), alarmCode));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kAlarmCode))
        {
            err = DataModel::Decode(reader, alarmCode);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace DoorLockAlarm.
namespace DoorStateChange {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kDoorState), doorState));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kDoorState))
        {
            err = DataModel::Decode(reader, doorState);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace DoorStateChange.
namespace LockOperation {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kLockOperationType), lockOperationType));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kOperationSource), operationSource));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kUserIndex), userIndex));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kFabricIndex), fabricIndex));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSourceNode), sourceNode));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCredentials), credentials));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kLockOperationType))
        {
            err = DataModel::Decode(reader, lockOperationType);
        }
        else if (__context_tag == to_underlying(Fields::kOperationSource))
        {
            err = DataModel::Decode(reader, operationSource);
        }
        else if (__context_tag == to_underlying(Fields::kUserIndex))
        {
            err = DataModel::Decode(reader, userIndex);
        }
        else if (__context_tag == to_underlying(Fields::kFabricIndex))
        {
            err = DataModel::Decode(reader, fabricIndex);
        }
        else if (__context_tag == to_underlying(Fields::kSourceNode))
        {
            err = DataModel::Decode(reader, sourceNode);
        }
        else if (__context_tag == to_underlying(Fields::kCredentials))
        {
            err = DataModel::Decode(reader, credentials);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace LockOperation.
namespace LockOperationError {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kLockOperationType), lockOperationType));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kOperationSource), operationSource));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kOperationError), operationError));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kUserIndex), userIndex));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kFabricIndex), fabricIndex));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSourceNode), sourceNode));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCredentials), credentials));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kLockOperationType))
        {
            err = DataModel::Decode(reader, lockOperationType);
        }
        else if (__context_tag == to_underlying(Fields::kOperationSource))
        {
            err = DataModel::Decode(reader, operationSource);
        }
        else if (__context_tag == to_underlying(Fields::kOperationError))
        {
            err = DataModel::Decode(reader, operationError);
        }
        else if (__context_tag == to_underlying(Fields::kUserIndex))
        {
            err = DataModel::Decode(reader, userIndex);
        }
        else if (__context_tag == to_underlying(Fields::kFabricIndex))
        {
            err = DataModel::Decode(reader, fabricIndex);
        }
        else if (__context_tag == to_underlying(Fields::kSourceNode))
        {
            err = DataModel::Decode(reader, sourceNode);
        }
        else if (__context_tag == to_underlying(Fields::kCredentials))
        {
            err = DataModel::Decode(reader, credentials);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace LockOperationError.
namespace LockUserChange {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kLockDataType), lockDataType));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kDataOperationType), dataOperationType));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kOperationSource), operationSource));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kUserIndex), userIndex));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kFabricIndex), fabricIndex));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSourceNode), sourceNode));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kDataIndex), dataIndex));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kLockDataType))
        {
            err = DataModel::Decode(reader, lockDataType);
        }
        else if (__context_tag == to_underlying(Fields::kDataOperationType))
        {
            err = DataModel::Decode(reader, dataOperationType);
        }
        else if (__context_tag == to_underlying(Fields::kOperationSource))
        {
            err = DataModel::Decode(reader, operationSource);
        }
        else if (__context_tag == to_underlying(Fields::kUserIndex))
        {
            err = DataModel::Decode(reader, userIndex);
        }
        else if (__context_tag == to_underlying(Fields::kFabricIndex))
        {
            err = DataModel::Decode(reader, fabricIndex);
        }
        else if (__context_tag == to_underlying(Fields::kSourceNode))
        {
            err = DataModel::Decode(reader, sourceNode);
        }
        else if (__context_tag == to_underlying(Fields::kDataIndex))
        {
            err = DataModel::Decode(reader, dataIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace LockUserChange.
} // namespace Events

} // namespace DoorLock
namespace WindowCovering {

namespace Commands {
namespace UpOrOpen {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace UpOrOpen.
namespace DownOrClose {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace DownOrClose.
namespace StopMotion {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace StopMotion.
namespace GoToLiftValue {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kLiftValue), liftValue);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kLiftValue))
        {
            err = DataModel::Decode(reader, liftValue);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GoToLiftValue.
namespace GoToLiftPercentage {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kLiftPercent100thsValue), liftPercent100thsValue);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kLiftPercent100thsValue))
        {
            err = DataModel::Decode(reader, liftPercent100thsValue);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GoToLiftPercentage.
namespace GoToTiltValue {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kTiltValue), tiltValue);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kTiltValue))
        {
            err = DataModel::Decode(reader, tiltValue);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GoToTiltValue.
namespace GoToTiltPercentage {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kTiltPercent100thsValue), tiltPercent100thsValue);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kTiltPercent100thsValue))
        {
            err = DataModel::Decode(reader, tiltPercent100thsValue);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GoToTiltPercentage.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::Type::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, type);
    case Attributes::PhysicalClosedLimitLift::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, physicalClosedLimitLift);
    case Attributes::PhysicalClosedLimitTilt::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, physicalClosedLimitTilt);
    case Attributes::CurrentPositionLift::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentPositionLift);
    case Attributes::CurrentPositionTilt::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentPositionTilt);
    case Attributes::NumberOfActuationsLift::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, numberOfActuationsLift);
    case Attributes::NumberOfActuationsTilt::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, numberOfActuationsTilt);
    case Attributes::ConfigStatus::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, configStatus);
    case Attributes::CurrentPositionLiftPercentage::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentPositionLiftPercentage);
    case Attributes::CurrentPositionTiltPercentage::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentPositionTiltPercentage);
    case Attributes::OperationalStatus::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, operationalStatus);
    case Attributes::TargetPositionLiftPercent100ths::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, targetPositionLiftPercent100ths);
    case Attributes::TargetPositionTiltPercent100ths::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, targetPositionTiltPercent100ths);
    case Attributes::EndProductType::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, endProductType);
    case Attributes::CurrentPositionLiftPercent100ths::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentPositionLiftPercent100ths);
    case Attributes::CurrentPositionTiltPercent100ths::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentPositionTiltPercent100ths);
    case Attributes::InstalledOpenLimitLift::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, installedOpenLimitLift);
    case Attributes::InstalledClosedLimitLift::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, installedClosedLimitLift);
    case Attributes::InstalledOpenLimitTilt::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, installedOpenLimitTilt);
    case Attributes::InstalledClosedLimitTilt::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, installedClosedLimitTilt);
    case Attributes::Mode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, mode);
    case Attributes::SafetyStatus::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, safetyStatus);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace WindowCovering
namespace ServiceArea {
namespace Structs {

namespace LandmarkInfoStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kLandmarkTag), landmarkTag);
    encoder.Encode(to_underlying(Fields::kRelativePositionTag), relativePositionTag);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kLandmarkTag))
        {
            err = DataModel::Decode(reader, landmarkTag);
        }
        else if (__context_tag == to_underlying(Fields::kRelativePositionTag))
        {
            err = DataModel::Decode(reader, relativePositionTag);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace LandmarkInfoStruct

namespace AreaInfoStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kLocationInfo), locationInfo);
    encoder.Encode(to_underlying(Fields::kLandmarkInfo), landmarkInfo);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kLocationInfo))
        {
            err = DataModel::Decode(reader, locationInfo);
        }
        else if (__context_tag == to_underlying(Fields::kLandmarkInfo))
        {
            err = DataModel::Decode(reader, landmarkInfo);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace AreaInfoStruct

namespace AreaStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kAreaID), areaID);
    encoder.Encode(to_underlying(Fields::kMapID), mapID);
    encoder.Encode(to_underlying(Fields::kAreaInfo), areaInfo);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kAreaID))
        {
            err = DataModel::Decode(reader, areaID);
        }
        else if (__context_tag == to_underlying(Fields::kMapID))
        {
            err = DataModel::Decode(reader, mapID);
        }
        else if (__context_tag == to_underlying(Fields::kAreaInfo))
        {
            err = DataModel::Decode(reader, areaInfo);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace AreaStruct

namespace MapStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kMapID), mapID);
    encoder.Encode(to_underlying(Fields::kName), name);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kMapID))
        {
            err = DataModel::Decode(reader, mapID);
        }
        else if (__context_tag == to_underlying(Fields::kName))
        {
            err = DataModel::Decode(reader, name);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace MapStruct

namespace ProgressStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kAreaID), areaID);
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kTotalOperationalTime), totalOperationalTime);
    encoder.Encode(to_underlying(Fields::kEstimatedTime), estimatedTime);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kAreaID))
        {
            err = DataModel::Decode(reader, areaID);
        }
        else if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kTotalOperationalTime))
        {
            err = DataModel::Decode(reader, totalOperationalTime);
        }
        else if (__context_tag == to_underlying(Fields::kEstimatedTime))
        {
            err = DataModel::Decode(reader, estimatedTime);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ProgressStruct
} // namespace Structs

namespace Commands {
namespace SelectAreas {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kNewAreas), newAreas);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNewAreas))
        {
            err = DataModel::Decode(reader, newAreas);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SelectAreas.
namespace SelectAreasResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kStatusText), statusText);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kStatusText))
        {
            err = DataModel::Decode(reader, statusText);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SelectAreasResponse.
namespace SkipArea {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kSkippedArea), skippedArea);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kSkippedArea))
        {
            err = DataModel::Decode(reader, skippedArea);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SkipArea.
namespace SkipAreaResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kStatusText), statusText);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kStatusText))
        {
            err = DataModel::Decode(reader, statusText);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SkipAreaResponse.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::SupportedAreas::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, supportedAreas);
    case Attributes::SupportedMaps::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, supportedMaps);
    case Attributes::SelectedAreas::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, selectedAreas);
    case Attributes::CurrentArea::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentArea);
    case Attributes::EstimatedEndTime::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, estimatedEndTime);
    case Attributes::Progress::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, progress);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace ServiceArea
namespace PumpConfigurationAndControl {

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::MaxPressure::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxPressure);
    case Attributes::MaxSpeed::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxSpeed);
    case Attributes::MaxFlow::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxFlow);
    case Attributes::MinConstPressure::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, minConstPressure);
    case Attributes::MaxConstPressure::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxConstPressure);
    case Attributes::MinCompPressure::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, minCompPressure);
    case Attributes::MaxCompPressure::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxCompPressure);
    case Attributes::MinConstSpeed::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, minConstSpeed);
    case Attributes::MaxConstSpeed::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxConstSpeed);
    case Attributes::MinConstFlow::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, minConstFlow);
    case Attributes::MaxConstFlow::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxConstFlow);
    case Attributes::MinConstTemp::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, minConstTemp);
    case Attributes::MaxConstTemp::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxConstTemp);
    case Attributes::PumpStatus::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, pumpStatus);
    case Attributes::EffectiveOperationMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, effectiveOperationMode);
    case Attributes::EffectiveControlMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, effectiveControlMode);
    case Attributes::Capacity::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, capacity);
    case Attributes::Speed::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, speed);
    case Attributes::LifetimeRunningHours::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, lifetimeRunningHours);
    case Attributes::Power::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, power);
    case Attributes::LifetimeEnergyConsumed::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, lifetimeEnergyConsumed);
    case Attributes::OperationMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, operationMode);
    case Attributes::ControlMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, controlMode);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace SupplyVoltageLow {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace SupplyVoltageLow.
namespace SupplyVoltageHigh {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace SupplyVoltageHigh.
namespace PowerMissingPhase {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace PowerMissingPhase.
namespace SystemPressureLow {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace SystemPressureLow.
namespace SystemPressureHigh {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace SystemPressureHigh.
namespace DryRunning {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace DryRunning.
namespace MotorTemperatureHigh {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace MotorTemperatureHigh.
namespace PumpMotorFatalFailure {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace PumpMotorFatalFailure.
namespace ElectronicTemperatureHigh {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace ElectronicTemperatureHigh.
namespace PumpBlocked {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace PumpBlocked.
namespace SensorFailure {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace SensorFailure.
namespace ElectronicNonFatalFailure {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace ElectronicNonFatalFailure.
namespace ElectronicFatalFailure {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace ElectronicFatalFailure.
namespace GeneralFault {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace GeneralFault.
namespace Leakage {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace Leakage.
namespace AirDetection {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace AirDetection.
namespace TurbineOperation {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace TurbineOperation.
} // namespace Events

} // namespace PumpConfigurationAndControl
namespace Thermostat {
namespace Structs {

namespace ScheduleTransitionStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kDayOfWeek), dayOfWeek);
    encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
    encoder.Encode(to_underlying(Fields::kPresetHandle), presetHandle);
    encoder.Encode(to_underlying(Fields::kSystemMode), systemMode);
    encoder.Encode(to_underlying(Fields::kCoolingSetpoint), coolingSetpoint);
    encoder.Encode(to_underlying(Fields::kHeatingSetpoint), heatingSetpoint);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kDayOfWeek))
        {
            err = DataModel::Decode(reader, dayOfWeek);
        }
        else if (__context_tag == to_underlying(Fields::kTransitionTime))
        {
            err = DataModel::Decode(reader, transitionTime);
        }
        else if (__context_tag == to_underlying(Fields::kPresetHandle))
        {
            err = DataModel::Decode(reader, presetHandle);
        }
        else if (__context_tag == to_underlying(Fields::kSystemMode))
        {
            err = DataModel::Decode(reader, systemMode);
        }
        else if (__context_tag == to_underlying(Fields::kCoolingSetpoint))
        {
            err = DataModel::Decode(reader, coolingSetpoint);
        }
        else if (__context_tag == to_underlying(Fields::kHeatingSetpoint))
        {
            err = DataModel::Decode(reader, heatingSetpoint);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ScheduleTransitionStruct

namespace ScheduleStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kScheduleHandle), scheduleHandle);
    encoder.Encode(to_underlying(Fields::kSystemMode), systemMode);
    encoder.Encode(to_underlying(Fields::kName), name);
    encoder.Encode(to_underlying(Fields::kPresetHandle), presetHandle);
    encoder.Encode(to_underlying(Fields::kTransitions), transitions);
    encoder.Encode(to_underlying(Fields::kBuiltIn), builtIn);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kScheduleHandle))
        {
            err = DataModel::Decode(reader, scheduleHandle);
        }
        else if (__context_tag == to_underlying(Fields::kSystemMode))
        {
            err = DataModel::Decode(reader, systemMode);
        }
        else if (__context_tag == to_underlying(Fields::kName))
        {
            err = DataModel::Decode(reader, name);
        }
        else if (__context_tag == to_underlying(Fields::kPresetHandle))
        {
            err = DataModel::Decode(reader, presetHandle);
        }
        else if (__context_tag == to_underlying(Fields::kTransitions))
        {
            err = DataModel::Decode(reader, transitions);
        }
        else if (__context_tag == to_underlying(Fields::kBuiltIn))
        {
            err = DataModel::Decode(reader, builtIn);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ScheduleStruct

namespace PresetStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kPresetHandle), presetHandle);
    encoder.Encode(to_underlying(Fields::kPresetScenario), presetScenario);
    encoder.Encode(to_underlying(Fields::kName), name);
    encoder.Encode(to_underlying(Fields::kCoolingSetpoint), coolingSetpoint);
    encoder.Encode(to_underlying(Fields::kHeatingSetpoint), heatingSetpoint);
    encoder.Encode(to_underlying(Fields::kBuiltIn), builtIn);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kPresetHandle))
        {
            err = DataModel::Decode(reader, presetHandle);
        }
        else if (__context_tag == to_underlying(Fields::kPresetScenario))
        {
            err = DataModel::Decode(reader, presetScenario);
        }
        else if (__context_tag == to_underlying(Fields::kName))
        {
            err = DataModel::Decode(reader, name);
        }
        else if (__context_tag == to_underlying(Fields::kCoolingSetpoint))
        {
            err = DataModel::Decode(reader, coolingSetpoint);
        }
        else if (__context_tag == to_underlying(Fields::kHeatingSetpoint))
        {
            err = DataModel::Decode(reader, heatingSetpoint);
        }
        else if (__context_tag == to_underlying(Fields::kBuiltIn))
        {
            err = DataModel::Decode(reader, builtIn);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace PresetStruct

namespace PresetTypeStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kPresetScenario), presetScenario);
    encoder.Encode(to_underlying(Fields::kNumberOfPresets), numberOfPresets);
    encoder.Encode(to_underlying(Fields::kPresetTypeFeatures), presetTypeFeatures);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kPresetScenario))
        {
            err = DataModel::Decode(reader, presetScenario);
        }
        else if (__context_tag == to_underlying(Fields::kNumberOfPresets))
        {
            err = DataModel::Decode(reader, numberOfPresets);
        }
        else if (__context_tag == to_underlying(Fields::kPresetTypeFeatures))
        {
            err = DataModel::Decode(reader, presetTypeFeatures);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace PresetTypeStruct

namespace ScheduleTypeStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kSystemMode), systemMode);
    encoder.Encode(to_underlying(Fields::kNumberOfSchedules), numberOfSchedules);
    encoder.Encode(to_underlying(Fields::kScheduleTypeFeatures), scheduleTypeFeatures);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kSystemMode))
        {
            err = DataModel::Decode(reader, systemMode);
        }
        else if (__context_tag == to_underlying(Fields::kNumberOfSchedules))
        {
            err = DataModel::Decode(reader, numberOfSchedules);
        }
        else if (__context_tag == to_underlying(Fields::kScheduleTypeFeatures))
        {
            err = DataModel::Decode(reader, scheduleTypeFeatures);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ScheduleTypeStruct

namespace WeeklyScheduleTransitionStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
    encoder.Encode(to_underlying(Fields::kHeatSetpoint), heatSetpoint);
    encoder.Encode(to_underlying(Fields::kCoolSetpoint), coolSetpoint);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kTransitionTime))
        {
            err = DataModel::Decode(reader, transitionTime);
        }
        else if (__context_tag == to_underlying(Fields::kHeatSetpoint))
        {
            err = DataModel::Decode(reader, heatSetpoint);
        }
        else if (__context_tag == to_underlying(Fields::kCoolSetpoint))
        {
            err = DataModel::Decode(reader, coolSetpoint);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace WeeklyScheduleTransitionStruct
} // namespace Structs

namespace Commands {
namespace SetpointRaiseLower {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kMode), mode);
    encoder.Encode(to_underlying(Fields::kAmount), amount);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kMode))
        {
            err = DataModel::Decode(reader, mode);
        }
        else if (__context_tag == to_underlying(Fields::kAmount))
        {
            err = DataModel::Decode(reader, amount);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetpointRaiseLower.
namespace GetWeeklyScheduleResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kNumberOfTransitionsForSequence), numberOfTransitionsForSequence);
    encoder.Encode(to_underlying(Fields::kDayOfWeekForSequence), dayOfWeekForSequence);
    encoder.Encode(to_underlying(Fields::kModeForSequence), modeForSequence);
    encoder.Encode(to_underlying(Fields::kTransitions), transitions);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNumberOfTransitionsForSequence))
        {
            err = DataModel::Decode(reader, numberOfTransitionsForSequence);
        }
        else if (__context_tag == to_underlying(Fields::kDayOfWeekForSequence))
        {
            err = DataModel::Decode(reader, dayOfWeekForSequence);
        }
        else if (__context_tag == to_underlying(Fields::kModeForSequence))
        {
            err = DataModel::Decode(reader, modeForSequence);
        }
        else if (__context_tag == to_underlying(Fields::kTransitions))
        {
            err = DataModel::Decode(reader, transitions);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GetWeeklyScheduleResponse.
namespace SetWeeklySchedule {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kNumberOfTransitionsForSequence), numberOfTransitionsForSequence);
    encoder.Encode(to_underlying(Fields::kDayOfWeekForSequence), dayOfWeekForSequence);
    encoder.Encode(to_underlying(Fields::kModeForSequence), modeForSequence);
    encoder.Encode(to_underlying(Fields::kTransitions), transitions);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNumberOfTransitionsForSequence))
        {
            err = DataModel::Decode(reader, numberOfTransitionsForSequence);
        }
        else if (__context_tag == to_underlying(Fields::kDayOfWeekForSequence))
        {
            err = DataModel::Decode(reader, dayOfWeekForSequence);
        }
        else if (__context_tag == to_underlying(Fields::kModeForSequence))
        {
            err = DataModel::Decode(reader, modeForSequence);
        }
        else if (__context_tag == to_underlying(Fields::kTransitions))
        {
            err = DataModel::Decode(reader, transitions);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetWeeklySchedule.
namespace GetWeeklySchedule {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kDaysToReturn), daysToReturn);
    encoder.Encode(to_underlying(Fields::kModeToReturn), modeToReturn);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kDaysToReturn))
        {
            err = DataModel::Decode(reader, daysToReturn);
        }
        else if (__context_tag == to_underlying(Fields::kModeToReturn))
        {
            err = DataModel::Decode(reader, modeToReturn);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GetWeeklySchedule.
namespace ClearWeeklySchedule {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace ClearWeeklySchedule.
namespace SetActiveScheduleRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kScheduleHandle), scheduleHandle);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kScheduleHandle))
        {
            err = DataModel::Decode(reader, scheduleHandle);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetActiveScheduleRequest.
namespace SetActivePresetRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kPresetHandle), presetHandle);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kPresetHandle))
        {
            err = DataModel::Decode(reader, presetHandle);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetActivePresetRequest.
namespace AtomicResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStatusCode), statusCode);
    encoder.Encode(to_underlying(Fields::kAttributeStatus), attributeStatus);
    encoder.Encode(to_underlying(Fields::kTimeout), timeout);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStatusCode))
        {
            err = DataModel::Decode(reader, statusCode);
        }
        else if (__context_tag == to_underlying(Fields::kAttributeStatus))
        {
            err = DataModel::Decode(reader, attributeStatus);
        }
        else if (__context_tag == to_underlying(Fields::kTimeout))
        {
            err = DataModel::Decode(reader, timeout);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace AtomicResponse.
namespace AtomicRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kRequestType), requestType);
    encoder.Encode(to_underlying(Fields::kAttributeRequests), attributeRequests);
    encoder.Encode(to_underlying(Fields::kTimeout), timeout);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kRequestType))
        {
            err = DataModel::Decode(reader, requestType);
        }
        else if (__context_tag == to_underlying(Fields::kAttributeRequests))
        {
            err = DataModel::Decode(reader, attributeRequests);
        }
        else if (__context_tag == to_underlying(Fields::kTimeout))
        {
            err = DataModel::Decode(reader, timeout);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace AtomicRequest.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::LocalTemperature::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, localTemperature);
    case Attributes::OutdoorTemperature::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, outdoorTemperature);
    case Attributes::Occupancy::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, occupancy);
    case Attributes::AbsMinHeatSetpointLimit::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, absMinHeatSetpointLimit);
    case Attributes::AbsMaxHeatSetpointLimit::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, absMaxHeatSetpointLimit);
    case Attributes::AbsMinCoolSetpointLimit::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, absMinCoolSetpointLimit);
    case Attributes::AbsMaxCoolSetpointLimit::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, absMaxCoolSetpointLimit);
    case Attributes::PICoolingDemand::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, PICoolingDemand);
    case Attributes::PIHeatingDemand::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, PIHeatingDemand);
    case Attributes::HVACSystemTypeConfiguration::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, HVACSystemTypeConfiguration);
    case Attributes::LocalTemperatureCalibration::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, localTemperatureCalibration);
    case Attributes::OccupiedCoolingSetpoint::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, occupiedCoolingSetpoint);
    case Attributes::OccupiedHeatingSetpoint::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, occupiedHeatingSetpoint);
    case Attributes::UnoccupiedCoolingSetpoint::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, unoccupiedCoolingSetpoint);
    case Attributes::UnoccupiedHeatingSetpoint::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, unoccupiedHeatingSetpoint);
    case Attributes::MinHeatSetpointLimit::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, minHeatSetpointLimit);
    case Attributes::MaxHeatSetpointLimit::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxHeatSetpointLimit);
    case Attributes::MinCoolSetpointLimit::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, minCoolSetpointLimit);
    case Attributes::MaxCoolSetpointLimit::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxCoolSetpointLimit);
    case Attributes::MinSetpointDeadBand::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, minSetpointDeadBand);
    case Attributes::RemoteSensing::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, remoteSensing);
    case Attributes::ControlSequenceOfOperation::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, controlSequenceOfOperation);
    case Attributes::SystemMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, systemMode);
    case Attributes::ThermostatRunningMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, thermostatRunningMode);
    case Attributes::StartOfWeek::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, startOfWeek);
    case Attributes::NumberOfWeeklyTransitions::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, numberOfWeeklyTransitions);
    case Attributes::NumberOfDailyTransitions::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, numberOfDailyTransitions);
    case Attributes::TemperatureSetpointHold::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, temperatureSetpointHold);
    case Attributes::TemperatureSetpointHoldDuration::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, temperatureSetpointHoldDuration);
    case Attributes::ThermostatProgrammingOperationMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, thermostatProgrammingOperationMode);
    case Attributes::ThermostatRunningState::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, thermostatRunningState);
    case Attributes::SetpointChangeSource::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, setpointChangeSource);
    case Attributes::SetpointChangeAmount::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, setpointChangeAmount);
    case Attributes::SetpointChangeSourceTimestamp::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, setpointChangeSourceTimestamp);
    case Attributes::OccupiedSetback::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, occupiedSetback);
    case Attributes::OccupiedSetbackMin::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, occupiedSetbackMin);
    case Attributes::OccupiedSetbackMax::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, occupiedSetbackMax);
    case Attributes::UnoccupiedSetback::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, unoccupiedSetback);
    case Attributes::UnoccupiedSetbackMin::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, unoccupiedSetbackMin);
    case Attributes::UnoccupiedSetbackMax::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, unoccupiedSetbackMax);
    case Attributes::EmergencyHeatDelta::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, emergencyHeatDelta);
    case Attributes::ACType::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, ACType);
    case Attributes::ACCapacity::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, ACCapacity);
    case Attributes::ACRefrigerantType::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, ACRefrigerantType);
    case Attributes::ACCompressorType::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, ACCompressorType);
    case Attributes::ACErrorCode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, ACErrorCode);
    case Attributes::ACLouverPosition::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, ACLouverPosition);
    case Attributes::ACCoilTemperature::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, ACCoilTemperature);
    case Attributes::ACCapacityformat::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, ACCapacityformat);
    case Attributes::PresetTypes::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, presetTypes);
    case Attributes::ScheduleTypes::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, scheduleTypes);
    case Attributes::NumberOfPresets::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, numberOfPresets);
    case Attributes::NumberOfSchedules::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, numberOfSchedules);
    case Attributes::NumberOfScheduleTransitions::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, numberOfScheduleTransitions);
    case Attributes::NumberOfScheduleTransitionPerDay::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, numberOfScheduleTransitionPerDay);
    case Attributes::ActivePresetHandle::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, activePresetHandle);
    case Attributes::ActiveScheduleHandle::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, activeScheduleHandle);
    case Attributes::Presets::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, presets);
    case Attributes::Schedules::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, schedules);
    case Attributes::SetpointHoldExpiryTimestamp::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, setpointHoldExpiryTimestamp);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace Thermostat
namespace FanControl {

namespace Commands {
namespace Step {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kDirection), direction);
    encoder.Encode(to_underlying(Fields::kWrap), wrap);
    encoder.Encode(to_underlying(Fields::kLowestOff), lowestOff);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kDirection))
        {
            err = DataModel::Decode(reader, direction);
        }
        else if (__context_tag == to_underlying(Fields::kWrap))
        {
            err = DataModel::Decode(reader, wrap);
        }
        else if (__context_tag == to_underlying(Fields::kLowestOff))
        {
            err = DataModel::Decode(reader, lowestOff);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace Step.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::FanMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, fanMode);
    case Attributes::FanModeSequence::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, fanModeSequence);
    case Attributes::PercentSetting::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, percentSetting);
    case Attributes::PercentCurrent::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, percentCurrent);
    case Attributes::SpeedMax::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, speedMax);
    case Attributes::SpeedSetting::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, speedSetting);
    case Attributes::SpeedCurrent::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, speedCurrent);
    case Attributes::RockSupport::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, rockSupport);
    case Attributes::RockSetting::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, rockSetting);
    case Attributes::WindSupport::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, windSupport);
    case Attributes::WindSetting::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, windSetting);
    case Attributes::AirflowDirection::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, airflowDirection);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace FanControl
namespace ThermostatUserInterfaceConfiguration {

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::TemperatureDisplayMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, temperatureDisplayMode);
    case Attributes::KeypadLockout::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, keypadLockout);
    case Attributes::ScheduleProgrammingVisibility::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, scheduleProgrammingVisibility);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace ThermostatUserInterfaceConfiguration
namespace ColorControl {

namespace Commands {
namespace MoveToHue {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kHue), hue);
    encoder.Encode(to_underlying(Fields::kDirection), direction);
    encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
    encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
    encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kHue))
        {
            err = DataModel::Decode(reader, hue);
        }
        else if (__context_tag == to_underlying(Fields::kDirection))
        {
            err = DataModel::Decode(reader, direction);
        }
        else if (__context_tag == to_underlying(Fields::kTransitionTime))
        {
            err = DataModel::Decode(reader, transitionTime);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsMask))
        {
            err = DataModel::Decode(reader, optionsMask);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsOverride))
        {
            err = DataModel::Decode(reader, optionsOverride);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace MoveToHue.
namespace MoveHue {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kMoveMode), moveMode);
    encoder.Encode(to_underlying(Fields::kRate), rate);
    encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
    encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kMoveMode))
        {
            err = DataModel::Decode(reader, moveMode);
        }
        else if (__context_tag == to_underlying(Fields::kRate))
        {
            err = DataModel::Decode(reader, rate);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsMask))
        {
            err = DataModel::Decode(reader, optionsMask);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsOverride))
        {
            err = DataModel::Decode(reader, optionsOverride);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace MoveHue.
namespace StepHue {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStepMode), stepMode);
    encoder.Encode(to_underlying(Fields::kStepSize), stepSize);
    encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
    encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
    encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStepMode))
        {
            err = DataModel::Decode(reader, stepMode);
        }
        else if (__context_tag == to_underlying(Fields::kStepSize))
        {
            err = DataModel::Decode(reader, stepSize);
        }
        else if (__context_tag == to_underlying(Fields::kTransitionTime))
        {
            err = DataModel::Decode(reader, transitionTime);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsMask))
        {
            err = DataModel::Decode(reader, optionsMask);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsOverride))
        {
            err = DataModel::Decode(reader, optionsOverride);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace StepHue.
namespace MoveToSaturation {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kSaturation), saturation);
    encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
    encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
    encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kSaturation))
        {
            err = DataModel::Decode(reader, saturation);
        }
        else if (__context_tag == to_underlying(Fields::kTransitionTime))
        {
            err = DataModel::Decode(reader, transitionTime);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsMask))
        {
            err = DataModel::Decode(reader, optionsMask);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsOverride))
        {
            err = DataModel::Decode(reader, optionsOverride);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace MoveToSaturation.
namespace MoveSaturation {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kMoveMode), moveMode);
    encoder.Encode(to_underlying(Fields::kRate), rate);
    encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
    encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kMoveMode))
        {
            err = DataModel::Decode(reader, moveMode);
        }
        else if (__context_tag == to_underlying(Fields::kRate))
        {
            err = DataModel::Decode(reader, rate);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsMask))
        {
            err = DataModel::Decode(reader, optionsMask);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsOverride))
        {
            err = DataModel::Decode(reader, optionsOverride);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace MoveSaturation.
namespace StepSaturation {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStepMode), stepMode);
    encoder.Encode(to_underlying(Fields::kStepSize), stepSize);
    encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
    encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
    encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStepMode))
        {
            err = DataModel::Decode(reader, stepMode);
        }
        else if (__context_tag == to_underlying(Fields::kStepSize))
        {
            err = DataModel::Decode(reader, stepSize);
        }
        else if (__context_tag == to_underlying(Fields::kTransitionTime))
        {
            err = DataModel::Decode(reader, transitionTime);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsMask))
        {
            err = DataModel::Decode(reader, optionsMask);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsOverride))
        {
            err = DataModel::Decode(reader, optionsOverride);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace StepSaturation.
namespace MoveToHueAndSaturation {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kHue), hue);
    encoder.Encode(to_underlying(Fields::kSaturation), saturation);
    encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
    encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
    encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kHue))
        {
            err = DataModel::Decode(reader, hue);
        }
        else if (__context_tag == to_underlying(Fields::kSaturation))
        {
            err = DataModel::Decode(reader, saturation);
        }
        else if (__context_tag == to_underlying(Fields::kTransitionTime))
        {
            err = DataModel::Decode(reader, transitionTime);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsMask))
        {
            err = DataModel::Decode(reader, optionsMask);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsOverride))
        {
            err = DataModel::Decode(reader, optionsOverride);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace MoveToHueAndSaturation.
namespace MoveToColor {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kColorX), colorX);
    encoder.Encode(to_underlying(Fields::kColorY), colorY);
    encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
    encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
    encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kColorX))
        {
            err = DataModel::Decode(reader, colorX);
        }
        else if (__context_tag == to_underlying(Fields::kColorY))
        {
            err = DataModel::Decode(reader, colorY);
        }
        else if (__context_tag == to_underlying(Fields::kTransitionTime))
        {
            err = DataModel::Decode(reader, transitionTime);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsMask))
        {
            err = DataModel::Decode(reader, optionsMask);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsOverride))
        {
            err = DataModel::Decode(reader, optionsOverride);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace MoveToColor.
namespace MoveColor {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kRateX), rateX);
    encoder.Encode(to_underlying(Fields::kRateY), rateY);
    encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
    encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kRateX))
        {
            err = DataModel::Decode(reader, rateX);
        }
        else if (__context_tag == to_underlying(Fields::kRateY))
        {
            err = DataModel::Decode(reader, rateY);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsMask))
        {
            err = DataModel::Decode(reader, optionsMask);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsOverride))
        {
            err = DataModel::Decode(reader, optionsOverride);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace MoveColor.
namespace StepColor {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStepX), stepX);
    encoder.Encode(to_underlying(Fields::kStepY), stepY);
    encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
    encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
    encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStepX))
        {
            err = DataModel::Decode(reader, stepX);
        }
        else if (__context_tag == to_underlying(Fields::kStepY))
        {
            err = DataModel::Decode(reader, stepY);
        }
        else if (__context_tag == to_underlying(Fields::kTransitionTime))
        {
            err = DataModel::Decode(reader, transitionTime);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsMask))
        {
            err = DataModel::Decode(reader, optionsMask);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsOverride))
        {
            err = DataModel::Decode(reader, optionsOverride);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace StepColor.
namespace MoveToColorTemperature {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kColorTemperatureMireds), colorTemperatureMireds);
    encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
    encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
    encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kColorTemperatureMireds))
        {
            err = DataModel::Decode(reader, colorTemperatureMireds);
        }
        else if (__context_tag == to_underlying(Fields::kTransitionTime))
        {
            err = DataModel::Decode(reader, transitionTime);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsMask))
        {
            err = DataModel::Decode(reader, optionsMask);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsOverride))
        {
            err = DataModel::Decode(reader, optionsOverride);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace MoveToColorTemperature.
namespace EnhancedMoveToHue {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kEnhancedHue), enhancedHue);
    encoder.Encode(to_underlying(Fields::kDirection), direction);
    encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
    encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
    encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kEnhancedHue))
        {
            err = DataModel::Decode(reader, enhancedHue);
        }
        else if (__context_tag == to_underlying(Fields::kDirection))
        {
            err = DataModel::Decode(reader, direction);
        }
        else if (__context_tag == to_underlying(Fields::kTransitionTime))
        {
            err = DataModel::Decode(reader, transitionTime);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsMask))
        {
            err = DataModel::Decode(reader, optionsMask);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsOverride))
        {
            err = DataModel::Decode(reader, optionsOverride);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace EnhancedMoveToHue.
namespace EnhancedMoveHue {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kMoveMode), moveMode);
    encoder.Encode(to_underlying(Fields::kRate), rate);
    encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
    encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kMoveMode))
        {
            err = DataModel::Decode(reader, moveMode);
        }
        else if (__context_tag == to_underlying(Fields::kRate))
        {
            err = DataModel::Decode(reader, rate);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsMask))
        {
            err = DataModel::Decode(reader, optionsMask);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsOverride))
        {
            err = DataModel::Decode(reader, optionsOverride);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace EnhancedMoveHue.
namespace EnhancedStepHue {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStepMode), stepMode);
    encoder.Encode(to_underlying(Fields::kStepSize), stepSize);
    encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
    encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
    encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStepMode))
        {
            err = DataModel::Decode(reader, stepMode);
        }
        else if (__context_tag == to_underlying(Fields::kStepSize))
        {
            err = DataModel::Decode(reader, stepSize);
        }
        else if (__context_tag == to_underlying(Fields::kTransitionTime))
        {
            err = DataModel::Decode(reader, transitionTime);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsMask))
        {
            err = DataModel::Decode(reader, optionsMask);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsOverride))
        {
            err = DataModel::Decode(reader, optionsOverride);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace EnhancedStepHue.
namespace EnhancedMoveToHueAndSaturation {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kEnhancedHue), enhancedHue);
    encoder.Encode(to_underlying(Fields::kSaturation), saturation);
    encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
    encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
    encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kEnhancedHue))
        {
            err = DataModel::Decode(reader, enhancedHue);
        }
        else if (__context_tag == to_underlying(Fields::kSaturation))
        {
            err = DataModel::Decode(reader, saturation);
        }
        else if (__context_tag == to_underlying(Fields::kTransitionTime))
        {
            err = DataModel::Decode(reader, transitionTime);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsMask))
        {
            err = DataModel::Decode(reader, optionsMask);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsOverride))
        {
            err = DataModel::Decode(reader, optionsOverride);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace EnhancedMoveToHueAndSaturation.
namespace ColorLoopSet {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kUpdateFlags), updateFlags);
    encoder.Encode(to_underlying(Fields::kAction), action);
    encoder.Encode(to_underlying(Fields::kDirection), direction);
    encoder.Encode(to_underlying(Fields::kTime), time);
    encoder.Encode(to_underlying(Fields::kStartHue), startHue);
    encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
    encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kUpdateFlags))
        {
            err = DataModel::Decode(reader, updateFlags);
        }
        else if (__context_tag == to_underlying(Fields::kAction))
        {
            err = DataModel::Decode(reader, action);
        }
        else if (__context_tag == to_underlying(Fields::kDirection))
        {
            err = DataModel::Decode(reader, direction);
        }
        else if (__context_tag == to_underlying(Fields::kTime))
        {
            err = DataModel::Decode(reader, time);
        }
        else if (__context_tag == to_underlying(Fields::kStartHue))
        {
            err = DataModel::Decode(reader, startHue);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsMask))
        {
            err = DataModel::Decode(reader, optionsMask);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsOverride))
        {
            err = DataModel::Decode(reader, optionsOverride);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ColorLoopSet.
namespace StopMoveStep {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
    encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kOptionsMask))
        {
            err = DataModel::Decode(reader, optionsMask);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsOverride))
        {
            err = DataModel::Decode(reader, optionsOverride);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace StopMoveStep.
namespace MoveColorTemperature {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kMoveMode), moveMode);
    encoder.Encode(to_underlying(Fields::kRate), rate);
    encoder.Encode(to_underlying(Fields::kColorTemperatureMinimumMireds), colorTemperatureMinimumMireds);
    encoder.Encode(to_underlying(Fields::kColorTemperatureMaximumMireds), colorTemperatureMaximumMireds);
    encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
    encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kMoveMode))
        {
            err = DataModel::Decode(reader, moveMode);
        }
        else if (__context_tag == to_underlying(Fields::kRate))
        {
            err = DataModel::Decode(reader, rate);
        }
        else if (__context_tag == to_underlying(Fields::kColorTemperatureMinimumMireds))
        {
            err = DataModel::Decode(reader, colorTemperatureMinimumMireds);
        }
        else if (__context_tag == to_underlying(Fields::kColorTemperatureMaximumMireds))
        {
            err = DataModel::Decode(reader, colorTemperatureMaximumMireds);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsMask))
        {
            err = DataModel::Decode(reader, optionsMask);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsOverride))
        {
            err = DataModel::Decode(reader, optionsOverride);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace MoveColorTemperature.
namespace StepColorTemperature {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStepMode), stepMode);
    encoder.Encode(to_underlying(Fields::kStepSize), stepSize);
    encoder.Encode(to_underlying(Fields::kTransitionTime), transitionTime);
    encoder.Encode(to_underlying(Fields::kColorTemperatureMinimumMireds), colorTemperatureMinimumMireds);
    encoder.Encode(to_underlying(Fields::kColorTemperatureMaximumMireds), colorTemperatureMaximumMireds);
    encoder.Encode(to_underlying(Fields::kOptionsMask), optionsMask);
    encoder.Encode(to_underlying(Fields::kOptionsOverride), optionsOverride);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStepMode))
        {
            err = DataModel::Decode(reader, stepMode);
        }
        else if (__context_tag == to_underlying(Fields::kStepSize))
        {
            err = DataModel::Decode(reader, stepSize);
        }
        else if (__context_tag == to_underlying(Fields::kTransitionTime))
        {
            err = DataModel::Decode(reader, transitionTime);
        }
        else if (__context_tag == to_underlying(Fields::kColorTemperatureMinimumMireds))
        {
            err = DataModel::Decode(reader, colorTemperatureMinimumMireds);
        }
        else if (__context_tag == to_underlying(Fields::kColorTemperatureMaximumMireds))
        {
            err = DataModel::Decode(reader, colorTemperatureMaximumMireds);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsMask))
        {
            err = DataModel::Decode(reader, optionsMask);
        }
        else if (__context_tag == to_underlying(Fields::kOptionsOverride))
        {
            err = DataModel::Decode(reader, optionsOverride);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace StepColorTemperature.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::CurrentHue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentHue);
    case Attributes::CurrentSaturation::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentSaturation);
    case Attributes::RemainingTime::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, remainingTime);
    case Attributes::CurrentX::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentX);
    case Attributes::CurrentY::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentY);
    case Attributes::DriftCompensation::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, driftCompensation);
    case Attributes::CompensationText::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, compensationText);
    case Attributes::ColorTemperatureMireds::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, colorTemperatureMireds);
    case Attributes::ColorMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, colorMode);
    case Attributes::Options::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, options);
    case Attributes::NumberOfPrimaries::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, numberOfPrimaries);
    case Attributes::Primary1X::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, primary1X);
    case Attributes::Primary1Y::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, primary1Y);
    case Attributes::Primary1Intensity::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, primary1Intensity);
    case Attributes::Primary2X::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, primary2X);
    case Attributes::Primary2Y::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, primary2Y);
    case Attributes::Primary2Intensity::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, primary2Intensity);
    case Attributes::Primary3X::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, primary3X);
    case Attributes::Primary3Y::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, primary3Y);
    case Attributes::Primary3Intensity::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, primary3Intensity);
    case Attributes::Primary4X::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, primary4X);
    case Attributes::Primary4Y::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, primary4Y);
    case Attributes::Primary4Intensity::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, primary4Intensity);
    case Attributes::Primary5X::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, primary5X);
    case Attributes::Primary5Y::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, primary5Y);
    case Attributes::Primary5Intensity::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, primary5Intensity);
    case Attributes::Primary6X::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, primary6X);
    case Attributes::Primary6Y::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, primary6Y);
    case Attributes::Primary6Intensity::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, primary6Intensity);
    case Attributes::WhitePointX::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, whitePointX);
    case Attributes::WhitePointY::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, whitePointY);
    case Attributes::ColorPointRX::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, colorPointRX);
    case Attributes::ColorPointRY::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, colorPointRY);
    case Attributes::ColorPointRIntensity::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, colorPointRIntensity);
    case Attributes::ColorPointGX::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, colorPointGX);
    case Attributes::ColorPointGY::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, colorPointGY);
    case Attributes::ColorPointGIntensity::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, colorPointGIntensity);
    case Attributes::ColorPointBX::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, colorPointBX);
    case Attributes::ColorPointBY::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, colorPointBY);
    case Attributes::ColorPointBIntensity::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, colorPointBIntensity);
    case Attributes::EnhancedCurrentHue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, enhancedCurrentHue);
    case Attributes::EnhancedColorMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, enhancedColorMode);
    case Attributes::ColorLoopActive::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, colorLoopActive);
    case Attributes::ColorLoopDirection::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, colorLoopDirection);
    case Attributes::ColorLoopTime::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, colorLoopTime);
    case Attributes::ColorLoopStartEnhancedHue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, colorLoopStartEnhancedHue);
    case Attributes::ColorLoopStoredEnhancedHue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, colorLoopStoredEnhancedHue);
    case Attributes::ColorCapabilities::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, colorCapabilities);
    case Attributes::ColorTempPhysicalMinMireds::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, colorTempPhysicalMinMireds);
    case Attributes::ColorTempPhysicalMaxMireds::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, colorTempPhysicalMaxMireds);
    case Attributes::CoupleColorTempToLevelMinMireds::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, coupleColorTempToLevelMinMireds);
    case Attributes::StartUpColorTemperatureMireds::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, startUpColorTemperatureMireds);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace ColorControl
namespace BallastConfiguration {

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::PhysicalMinLevel::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, physicalMinLevel);
    case Attributes::PhysicalMaxLevel::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, physicalMaxLevel);
    case Attributes::BallastStatus::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, ballastStatus);
    case Attributes::MinLevel::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, minLevel);
    case Attributes::MaxLevel::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxLevel);
    case Attributes::IntrinsicBallastFactor::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, intrinsicBallastFactor);
    case Attributes::BallastFactorAdjustment::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, ballastFactorAdjustment);
    case Attributes::LampQuantity::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, lampQuantity);
    case Attributes::LampType::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, lampType);
    case Attributes::LampManufacturer::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, lampManufacturer);
    case Attributes::LampRatedHours::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, lampRatedHours);
    case Attributes::LampBurnHours::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, lampBurnHours);
    case Attributes::LampAlarmMode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, lampAlarmMode);
    case Attributes::LampBurnHoursTripPoint::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, lampBurnHoursTripPoint);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace BallastConfiguration
namespace IlluminanceMeasurement {

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::MeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measuredValue);
    case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, minMeasuredValue);
    case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxMeasuredValue);
    case Attributes::Tolerance::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, tolerance);
    case Attributes::LightSensorType::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, lightSensorType);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace IlluminanceMeasurement
namespace TemperatureMeasurement {

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::MeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measuredValue);
    case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, minMeasuredValue);
    case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxMeasuredValue);
    case Attributes::Tolerance::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, tolerance);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace TemperatureMeasurement
namespace PressureMeasurement {

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::MeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measuredValue);
    case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, minMeasuredValue);
    case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxMeasuredValue);
    case Attributes::Tolerance::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, tolerance);
    case Attributes::ScaledValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, scaledValue);
    case Attributes::MinScaledValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, minScaledValue);
    case Attributes::MaxScaledValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxScaledValue);
    case Attributes::ScaledTolerance::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, scaledTolerance);
    case Attributes::Scale::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, scale);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace PressureMeasurement
namespace FlowMeasurement {

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::MeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measuredValue);
    case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, minMeasuredValue);
    case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxMeasuredValue);
    case Attributes::Tolerance::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, tolerance);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace FlowMeasurement
namespace RelativeHumidityMeasurement {

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::MeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measuredValue);
    case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, minMeasuredValue);
    case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxMeasuredValue);
    case Attributes::Tolerance::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, tolerance);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace RelativeHumidityMeasurement
namespace OccupancySensing {
namespace Structs {

namespace HoldTimeLimitsStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kHoldTimeMin), holdTimeMin);
    encoder.Encode(to_underlying(Fields::kHoldTimeMax), holdTimeMax);
    encoder.Encode(to_underlying(Fields::kHoldTimeDefault), holdTimeDefault);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kHoldTimeMin))
        {
            err = DataModel::Decode(reader, holdTimeMin);
        }
        else if (__context_tag == to_underlying(Fields::kHoldTimeMax))
        {
            err = DataModel::Decode(reader, holdTimeMax);
        }
        else if (__context_tag == to_underlying(Fields::kHoldTimeDefault))
        {
            err = DataModel::Decode(reader, holdTimeDefault);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace HoldTimeLimitsStruct
} // namespace Structs

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::Occupancy::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, occupancy);
    case Attributes::OccupancySensorType::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, occupancySensorType);
    case Attributes::OccupancySensorTypeBitmap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, occupancySensorTypeBitmap);
    case Attributes::HoldTime::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, holdTime);
    case Attributes::HoldTimeLimits::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, holdTimeLimits);
    case Attributes::PIROccupiedToUnoccupiedDelay::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, PIROccupiedToUnoccupiedDelay);
    case Attributes::PIRUnoccupiedToOccupiedDelay::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, PIRUnoccupiedToOccupiedDelay);
    case Attributes::PIRUnoccupiedToOccupiedThreshold::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, PIRUnoccupiedToOccupiedThreshold);
    case Attributes::UltrasonicOccupiedToUnoccupiedDelay::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, ultrasonicOccupiedToUnoccupiedDelay);
    case Attributes::UltrasonicUnoccupiedToOccupiedDelay::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, ultrasonicUnoccupiedToOccupiedDelay);
    case Attributes::UltrasonicUnoccupiedToOccupiedThreshold::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, ultrasonicUnoccupiedToOccupiedThreshold);
    case Attributes::PhysicalContactOccupiedToUnoccupiedDelay::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, physicalContactOccupiedToUnoccupiedDelay);
    case Attributes::PhysicalContactUnoccupiedToOccupiedDelay::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, physicalContactUnoccupiedToOccupiedDelay);
    case Attributes::PhysicalContactUnoccupiedToOccupiedThreshold::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, physicalContactUnoccupiedToOccupiedThreshold);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace OccupancyChanged {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kOccupancy), occupancy));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kOccupancy))
        {
            err = DataModel::Decode(reader, occupancy);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace OccupancyChanged.
} // namespace Events

} // namespace OccupancySensing
namespace CarbonMonoxideConcentrationMeasurement {

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::MeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measuredValue);
    case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, minMeasuredValue);
    case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxMeasuredValue);
    case Attributes::PeakMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, peakMeasuredValue);
    case Attributes::PeakMeasuredValueWindow::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, peakMeasuredValueWindow);
    case Attributes::AverageMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, averageMeasuredValue);
    case Attributes::AverageMeasuredValueWindow::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, averageMeasuredValueWindow);
    case Attributes::Uncertainty::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, uncertainty);
    case Attributes::MeasurementUnit::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measurementUnit);
    case Attributes::MeasurementMedium::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measurementMedium);
    case Attributes::LevelValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, levelValue);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace CarbonMonoxideConcentrationMeasurement
namespace CarbonDioxideConcentrationMeasurement {

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::MeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measuredValue);
    case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, minMeasuredValue);
    case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxMeasuredValue);
    case Attributes::PeakMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, peakMeasuredValue);
    case Attributes::PeakMeasuredValueWindow::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, peakMeasuredValueWindow);
    case Attributes::AverageMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, averageMeasuredValue);
    case Attributes::AverageMeasuredValueWindow::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, averageMeasuredValueWindow);
    case Attributes::Uncertainty::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, uncertainty);
    case Attributes::MeasurementUnit::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measurementUnit);
    case Attributes::MeasurementMedium::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measurementMedium);
    case Attributes::LevelValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, levelValue);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace CarbonDioxideConcentrationMeasurement
namespace NitrogenDioxideConcentrationMeasurement {

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::MeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measuredValue);
    case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, minMeasuredValue);
    case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxMeasuredValue);
    case Attributes::PeakMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, peakMeasuredValue);
    case Attributes::PeakMeasuredValueWindow::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, peakMeasuredValueWindow);
    case Attributes::AverageMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, averageMeasuredValue);
    case Attributes::AverageMeasuredValueWindow::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, averageMeasuredValueWindow);
    case Attributes::Uncertainty::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, uncertainty);
    case Attributes::MeasurementUnit::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measurementUnit);
    case Attributes::MeasurementMedium::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measurementMedium);
    case Attributes::LevelValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, levelValue);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace NitrogenDioxideConcentrationMeasurement
namespace OzoneConcentrationMeasurement {

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::MeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measuredValue);
    case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, minMeasuredValue);
    case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxMeasuredValue);
    case Attributes::PeakMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, peakMeasuredValue);
    case Attributes::PeakMeasuredValueWindow::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, peakMeasuredValueWindow);
    case Attributes::AverageMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, averageMeasuredValue);
    case Attributes::AverageMeasuredValueWindow::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, averageMeasuredValueWindow);
    case Attributes::Uncertainty::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, uncertainty);
    case Attributes::MeasurementUnit::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measurementUnit);
    case Attributes::MeasurementMedium::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measurementMedium);
    case Attributes::LevelValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, levelValue);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace OzoneConcentrationMeasurement
namespace Pm25ConcentrationMeasurement {

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::MeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measuredValue);
    case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, minMeasuredValue);
    case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxMeasuredValue);
    case Attributes::PeakMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, peakMeasuredValue);
    case Attributes::PeakMeasuredValueWindow::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, peakMeasuredValueWindow);
    case Attributes::AverageMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, averageMeasuredValue);
    case Attributes::AverageMeasuredValueWindow::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, averageMeasuredValueWindow);
    case Attributes::Uncertainty::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, uncertainty);
    case Attributes::MeasurementUnit::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measurementUnit);
    case Attributes::MeasurementMedium::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measurementMedium);
    case Attributes::LevelValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, levelValue);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace Pm25ConcentrationMeasurement
namespace FormaldehydeConcentrationMeasurement {

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::MeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measuredValue);
    case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, minMeasuredValue);
    case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxMeasuredValue);
    case Attributes::PeakMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, peakMeasuredValue);
    case Attributes::PeakMeasuredValueWindow::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, peakMeasuredValueWindow);
    case Attributes::AverageMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, averageMeasuredValue);
    case Attributes::AverageMeasuredValueWindow::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, averageMeasuredValueWindow);
    case Attributes::Uncertainty::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, uncertainty);
    case Attributes::MeasurementUnit::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measurementUnit);
    case Attributes::MeasurementMedium::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measurementMedium);
    case Attributes::LevelValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, levelValue);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace FormaldehydeConcentrationMeasurement
namespace Pm1ConcentrationMeasurement {

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::MeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measuredValue);
    case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, minMeasuredValue);
    case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxMeasuredValue);
    case Attributes::PeakMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, peakMeasuredValue);
    case Attributes::PeakMeasuredValueWindow::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, peakMeasuredValueWindow);
    case Attributes::AverageMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, averageMeasuredValue);
    case Attributes::AverageMeasuredValueWindow::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, averageMeasuredValueWindow);
    case Attributes::Uncertainty::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, uncertainty);
    case Attributes::MeasurementUnit::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measurementUnit);
    case Attributes::MeasurementMedium::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measurementMedium);
    case Attributes::LevelValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, levelValue);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace Pm1ConcentrationMeasurement
namespace Pm10ConcentrationMeasurement {

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::MeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measuredValue);
    case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, minMeasuredValue);
    case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxMeasuredValue);
    case Attributes::PeakMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, peakMeasuredValue);
    case Attributes::PeakMeasuredValueWindow::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, peakMeasuredValueWindow);
    case Attributes::AverageMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, averageMeasuredValue);
    case Attributes::AverageMeasuredValueWindow::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, averageMeasuredValueWindow);
    case Attributes::Uncertainty::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, uncertainty);
    case Attributes::MeasurementUnit::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measurementUnit);
    case Attributes::MeasurementMedium::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measurementMedium);
    case Attributes::LevelValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, levelValue);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace Pm10ConcentrationMeasurement
namespace TotalVolatileOrganicCompoundsConcentrationMeasurement {

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::MeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measuredValue);
    case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, minMeasuredValue);
    case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxMeasuredValue);
    case Attributes::PeakMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, peakMeasuredValue);
    case Attributes::PeakMeasuredValueWindow::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, peakMeasuredValueWindow);
    case Attributes::AverageMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, averageMeasuredValue);
    case Attributes::AverageMeasuredValueWindow::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, averageMeasuredValueWindow);
    case Attributes::Uncertainty::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, uncertainty);
    case Attributes::MeasurementUnit::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measurementUnit);
    case Attributes::MeasurementMedium::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measurementMedium);
    case Attributes::LevelValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, levelValue);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace TotalVolatileOrganicCompoundsConcentrationMeasurement
namespace RadonConcentrationMeasurement {

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::MeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measuredValue);
    case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, minMeasuredValue);
    case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxMeasuredValue);
    case Attributes::PeakMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, peakMeasuredValue);
    case Attributes::PeakMeasuredValueWindow::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, peakMeasuredValueWindow);
    case Attributes::AverageMeasuredValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, averageMeasuredValue);
    case Attributes::AverageMeasuredValueWindow::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, averageMeasuredValueWindow);
    case Attributes::Uncertainty::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, uncertainty);
    case Attributes::MeasurementUnit::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measurementUnit);
    case Attributes::MeasurementMedium::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, measurementMedium);
    case Attributes::LevelValue::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, levelValue);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace RadonConcentrationMeasurement
namespace WiFiNetworkManagement {

namespace Commands {
namespace NetworkPassphraseRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace NetworkPassphraseRequest.
namespace NetworkPassphraseResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kPassphrase), passphrase);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kPassphrase))
        {
            err = DataModel::Decode(reader, passphrase);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace NetworkPassphraseResponse.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::Ssid::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, ssid);
    case Attributes::PassphraseSurrogate::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, passphraseSurrogate);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace WiFiNetworkManagement
namespace ThreadBorderRouterManagement {

namespace Commands {
namespace GetActiveDatasetRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace GetActiveDatasetRequest.
namespace GetPendingDatasetRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace GetPendingDatasetRequest.
namespace DatasetResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kDataset), dataset);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kDataset))
        {
            err = DataModel::Decode(reader, dataset);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace DatasetResponse.
namespace SetActiveDatasetRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kActiveDataset), activeDataset);
    encoder.Encode(to_underlying(Fields::kBreadcrumb), breadcrumb);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kActiveDataset))
        {
            err = DataModel::Decode(reader, activeDataset);
        }
        else if (__context_tag == to_underlying(Fields::kBreadcrumb))
        {
            err = DataModel::Decode(reader, breadcrumb);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetActiveDatasetRequest.
namespace SetPendingDatasetRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kPendingDataset), pendingDataset);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kPendingDataset))
        {
            err = DataModel::Decode(reader, pendingDataset);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetPendingDatasetRequest.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::BorderRouterName::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, borderRouterName);
    case Attributes::BorderAgentID::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, borderAgentID);
    case Attributes::ThreadVersion::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, threadVersion);
    case Attributes::InterfaceEnabled::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, interfaceEnabled);
    case Attributes::ActiveDatasetTimestamp::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, activeDatasetTimestamp);
    case Attributes::PendingDatasetTimestamp::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, pendingDatasetTimestamp);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace ThreadBorderRouterManagement
namespace ThreadNetworkDirectory {
namespace Structs {

namespace ThreadNetworkStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kExtendedPanID), extendedPanID);
    encoder.Encode(to_underlying(Fields::kNetworkName), networkName);
    encoder.Encode(to_underlying(Fields::kChannel), channel);
    encoder.Encode(to_underlying(Fields::kActiveTimestamp), activeTimestamp);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kExtendedPanID))
        {
            err = DataModel::Decode(reader, extendedPanID);
        }
        else if (__context_tag == to_underlying(Fields::kNetworkName))
        {
            err = DataModel::Decode(reader, networkName);
        }
        else if (__context_tag == to_underlying(Fields::kChannel))
        {
            err = DataModel::Decode(reader, channel);
        }
        else if (__context_tag == to_underlying(Fields::kActiveTimestamp))
        {
            err = DataModel::Decode(reader, activeTimestamp);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ThreadNetworkStruct
} // namespace Structs

namespace Commands {
namespace AddNetwork {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kOperationalDataset), operationalDataset);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kOperationalDataset))
        {
            err = DataModel::Decode(reader, operationalDataset);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace AddNetwork.
namespace RemoveNetwork {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kExtendedPanID), extendedPanID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kExtendedPanID))
        {
            err = DataModel::Decode(reader, extendedPanID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace RemoveNetwork.
namespace GetOperationalDataset {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kExtendedPanID), extendedPanID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kExtendedPanID))
        {
            err = DataModel::Decode(reader, extendedPanID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GetOperationalDataset.
namespace OperationalDatasetResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kOperationalDataset), operationalDataset);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kOperationalDataset))
        {
            err = DataModel::Decode(reader, operationalDataset);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace OperationalDatasetResponse.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::PreferredExtendedPanID::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, preferredExtendedPanID);
    case Attributes::ThreadNetworks::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, threadNetworks);
    case Attributes::ThreadNetworkTableSize::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, threadNetworkTableSize);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace ThreadNetworkDirectory
namespace WakeOnLan {

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::MACAddress::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, MACAddress);
    case Attributes::LinkLocalAddress::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, linkLocalAddress);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace WakeOnLan
namespace Channel {
namespace Structs {

namespace ProgramCastStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kName), name);
    encoder.Encode(to_underlying(Fields::kRole), role);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kName))
        {
            err = DataModel::Decode(reader, name);
        }
        else if (__context_tag == to_underlying(Fields::kRole))
        {
            err = DataModel::Decode(reader, role);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ProgramCastStruct

namespace ProgramCategoryStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kCategory), category);
    encoder.Encode(to_underlying(Fields::kSubCategory), subCategory);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCategory))
        {
            err = DataModel::Decode(reader, category);
        }
        else if (__context_tag == to_underlying(Fields::kSubCategory))
        {
            err = DataModel::Decode(reader, subCategory);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ProgramCategoryStruct

namespace SeriesInfoStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kSeason), season);
    encoder.Encode(to_underlying(Fields::kEpisode), episode);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kSeason))
        {
            err = DataModel::Decode(reader, season);
        }
        else if (__context_tag == to_underlying(Fields::kEpisode))
        {
            err = DataModel::Decode(reader, episode);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace SeriesInfoStruct

namespace ChannelInfoStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kMajorNumber), majorNumber);
    encoder.Encode(to_underlying(Fields::kMinorNumber), minorNumber);
    encoder.Encode(to_underlying(Fields::kName), name);
    encoder.Encode(to_underlying(Fields::kCallSign), callSign);
    encoder.Encode(to_underlying(Fields::kAffiliateCallSign), affiliateCallSign);
    encoder.Encode(to_underlying(Fields::kIdentifier), identifier);
    encoder.Encode(to_underlying(Fields::kType), type);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kMajorNumber))
        {
            err = DataModel::Decode(reader, majorNumber);
        }
        else if (__context_tag == to_underlying(Fields::kMinorNumber))
        {
            err = DataModel::Decode(reader, minorNumber);
        }
        else if (__context_tag == to_underlying(Fields::kName))
        {
            err = DataModel::Decode(reader, name);
        }
        else if (__context_tag == to_underlying(Fields::kCallSign))
        {
            err = DataModel::Decode(reader, callSign);
        }
        else if (__context_tag == to_underlying(Fields::kAffiliateCallSign))
        {
            err = DataModel::Decode(reader, affiliateCallSign);
        }
        else if (__context_tag == to_underlying(Fields::kIdentifier))
        {
            err = DataModel::Decode(reader, identifier);
        }
        else if (__context_tag == to_underlying(Fields::kType))
        {
            err = DataModel::Decode(reader, type);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ChannelInfoStruct

namespace ProgramStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kIdentifier), identifier);
    encoder.Encode(to_underlying(Fields::kChannel), channel);
    encoder.Encode(to_underlying(Fields::kStartTime), startTime);
    encoder.Encode(to_underlying(Fields::kEndTime), endTime);
    encoder.Encode(to_underlying(Fields::kTitle), title);
    encoder.Encode(to_underlying(Fields::kSubtitle), subtitle);
    encoder.Encode(to_underlying(Fields::kDescription), description);
    encoder.Encode(to_underlying(Fields::kAudioLanguages), audioLanguages);
    encoder.Encode(to_underlying(Fields::kRatings), ratings);
    encoder.Encode(to_underlying(Fields::kThumbnailUrl), thumbnailUrl);
    encoder.Encode(to_underlying(Fields::kPosterArtUrl), posterArtUrl);
    encoder.Encode(to_underlying(Fields::kDvbiUrl), dvbiUrl);
    encoder.Encode(to_underlying(Fields::kReleaseDate), releaseDate);
    encoder.Encode(to_underlying(Fields::kParentalGuidanceText), parentalGuidanceText);
    encoder.Encode(to_underlying(Fields::kRecordingFlag), recordingFlag);
    encoder.Encode(to_underlying(Fields::kSeriesInfo), seriesInfo);
    encoder.Encode(to_underlying(Fields::kCategoryList), categoryList);
    encoder.Encode(to_underlying(Fields::kCastList), castList);
    encoder.Encode(to_underlying(Fields::kExternalIDList), externalIDList);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kIdentifier))
        {
            err = DataModel::Decode(reader, identifier);
        }
        else if (__context_tag == to_underlying(Fields::kChannel))
        {
            err = DataModel::Decode(reader, channel);
        }
        else if (__context_tag == to_underlying(Fields::kStartTime))
        {
            err = DataModel::Decode(reader, startTime);
        }
        else if (__context_tag == to_underlying(Fields::kEndTime))
        {
            err = DataModel::Decode(reader, endTime);
        }
        else if (__context_tag == to_underlying(Fields::kTitle))
        {
            err = DataModel::Decode(reader, title);
        }
        else if (__context_tag == to_underlying(Fields::kSubtitle))
        {
            err = DataModel::Decode(reader, subtitle);
        }
        else if (__context_tag == to_underlying(Fields::kDescription))
        {
            err = DataModel::Decode(reader, description);
        }
        else if (__context_tag == to_underlying(Fields::kAudioLanguages))
        {
            err = DataModel::Decode(reader, audioLanguages);
        }
        else if (__context_tag == to_underlying(Fields::kRatings))
        {
            err = DataModel::Decode(reader, ratings);
        }
        else if (__context_tag == to_underlying(Fields::kThumbnailUrl))
        {
            err = DataModel::Decode(reader, thumbnailUrl);
        }
        else if (__context_tag == to_underlying(Fields::kPosterArtUrl))
        {
            err = DataModel::Decode(reader, posterArtUrl);
        }
        else if (__context_tag == to_underlying(Fields::kDvbiUrl))
        {
            err = DataModel::Decode(reader, dvbiUrl);
        }
        else if (__context_tag == to_underlying(Fields::kReleaseDate))
        {
            err = DataModel::Decode(reader, releaseDate);
        }
        else if (__context_tag == to_underlying(Fields::kParentalGuidanceText))
        {
            err = DataModel::Decode(reader, parentalGuidanceText);
        }
        else if (__context_tag == to_underlying(Fields::kRecordingFlag))
        {
            err = DataModel::Decode(reader, recordingFlag);
        }
        else if (__context_tag == to_underlying(Fields::kSeriesInfo))
        {
            err = DataModel::Decode(reader, seriesInfo);
        }
        else if (__context_tag == to_underlying(Fields::kCategoryList))
        {
            err = DataModel::Decode(reader, categoryList);
        }
        else if (__context_tag == to_underlying(Fields::kCastList))
        {
            err = DataModel::Decode(reader, castList);
        }
        else if (__context_tag == to_underlying(Fields::kExternalIDList))
        {
            err = DataModel::Decode(reader, externalIDList);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ProgramStruct

namespace PageTokenStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kLimit), limit);
    encoder.Encode(to_underlying(Fields::kAfter), after);
    encoder.Encode(to_underlying(Fields::kBefore), before);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kLimit))
        {
            err = DataModel::Decode(reader, limit);
        }
        else if (__context_tag == to_underlying(Fields::kAfter))
        {
            err = DataModel::Decode(reader, after);
        }
        else if (__context_tag == to_underlying(Fields::kBefore))
        {
            err = DataModel::Decode(reader, before);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace PageTokenStruct

namespace ChannelPagingStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kPreviousToken), previousToken);
    encoder.Encode(to_underlying(Fields::kNextToken), nextToken);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kPreviousToken))
        {
            err = DataModel::Decode(reader, previousToken);
        }
        else if (__context_tag == to_underlying(Fields::kNextToken))
        {
            err = DataModel::Decode(reader, nextToken);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ChannelPagingStruct

namespace AdditionalInfoStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kName), name);
    encoder.Encode(to_underlying(Fields::kValue), value);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kName))
        {
            err = DataModel::Decode(reader, name);
        }
        else if (__context_tag == to_underlying(Fields::kValue))
        {
            err = DataModel::Decode(reader, value);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace AdditionalInfoStruct

namespace LineupInfoStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kOperatorName), operatorName);
    encoder.Encode(to_underlying(Fields::kLineupName), lineupName);
    encoder.Encode(to_underlying(Fields::kPostalCode), postalCode);
    encoder.Encode(to_underlying(Fields::kLineupInfoType), lineupInfoType);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kOperatorName))
        {
            err = DataModel::Decode(reader, operatorName);
        }
        else if (__context_tag == to_underlying(Fields::kLineupName))
        {
            err = DataModel::Decode(reader, lineupName);
        }
        else if (__context_tag == to_underlying(Fields::kPostalCode))
        {
            err = DataModel::Decode(reader, postalCode);
        }
        else if (__context_tag == to_underlying(Fields::kLineupInfoType))
        {
            err = DataModel::Decode(reader, lineupInfoType);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace LineupInfoStruct
} // namespace Structs

namespace Commands {
namespace ChangeChannel {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kMatch), match);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kMatch))
        {
            err = DataModel::Decode(reader, match);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ChangeChannel.
namespace ChangeChannelResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kData), data);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kData))
        {
            err = DataModel::Decode(reader, data);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ChangeChannelResponse.
namespace ChangeChannelByNumber {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kMajorNumber), majorNumber);
    encoder.Encode(to_underlying(Fields::kMinorNumber), minorNumber);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kMajorNumber))
        {
            err = DataModel::Decode(reader, majorNumber);
        }
        else if (__context_tag == to_underlying(Fields::kMinorNumber))
        {
            err = DataModel::Decode(reader, minorNumber);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ChangeChannelByNumber.
namespace SkipChannel {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kCount), count);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCount))
        {
            err = DataModel::Decode(reader, count);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SkipChannel.
namespace GetProgramGuide {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStartTime), startTime);
    encoder.Encode(to_underlying(Fields::kEndTime), endTime);
    encoder.Encode(to_underlying(Fields::kChannelList), channelList);
    encoder.Encode(to_underlying(Fields::kPageToken), pageToken);
    encoder.Encode(to_underlying(Fields::kRecordingFlag), recordingFlag);
    encoder.Encode(to_underlying(Fields::kExternalIDList), externalIDList);
    encoder.Encode(to_underlying(Fields::kData), data);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStartTime))
        {
            err = DataModel::Decode(reader, startTime);
        }
        else if (__context_tag == to_underlying(Fields::kEndTime))
        {
            err = DataModel::Decode(reader, endTime);
        }
        else if (__context_tag == to_underlying(Fields::kChannelList))
        {
            err = DataModel::Decode(reader, channelList);
        }
        else if (__context_tag == to_underlying(Fields::kPageToken))
        {
            err = DataModel::Decode(reader, pageToken);
        }
        else if (__context_tag == to_underlying(Fields::kRecordingFlag))
        {
            err = DataModel::Decode(reader, recordingFlag);
        }
        else if (__context_tag == to_underlying(Fields::kExternalIDList))
        {
            err = DataModel::Decode(reader, externalIDList);
        }
        else if (__context_tag == to_underlying(Fields::kData))
        {
            err = DataModel::Decode(reader, data);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GetProgramGuide.
namespace ProgramGuideResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kPaging), paging);
    encoder.Encode(to_underlying(Fields::kProgramList), programList);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kPaging))
        {
            err = DataModel::Decode(reader, paging);
        }
        else if (__context_tag == to_underlying(Fields::kProgramList))
        {
            err = DataModel::Decode(reader, programList);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ProgramGuideResponse.
namespace RecordProgram {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kProgramIdentifier), programIdentifier);
    encoder.Encode(to_underlying(Fields::kShouldRecordSeries), shouldRecordSeries);
    encoder.Encode(to_underlying(Fields::kExternalIDList), externalIDList);
    encoder.Encode(to_underlying(Fields::kData), data);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kProgramIdentifier))
        {
            err = DataModel::Decode(reader, programIdentifier);
        }
        else if (__context_tag == to_underlying(Fields::kShouldRecordSeries))
        {
            err = DataModel::Decode(reader, shouldRecordSeries);
        }
        else if (__context_tag == to_underlying(Fields::kExternalIDList))
        {
            err = DataModel::Decode(reader, externalIDList);
        }
        else if (__context_tag == to_underlying(Fields::kData))
        {
            err = DataModel::Decode(reader, data);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace RecordProgram.
namespace CancelRecordProgram {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kProgramIdentifier), programIdentifier);
    encoder.Encode(to_underlying(Fields::kShouldRecordSeries), shouldRecordSeries);
    encoder.Encode(to_underlying(Fields::kExternalIDList), externalIDList);
    encoder.Encode(to_underlying(Fields::kData), data);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kProgramIdentifier))
        {
            err = DataModel::Decode(reader, programIdentifier);
        }
        else if (__context_tag == to_underlying(Fields::kShouldRecordSeries))
        {
            err = DataModel::Decode(reader, shouldRecordSeries);
        }
        else if (__context_tag == to_underlying(Fields::kExternalIDList))
        {
            err = DataModel::Decode(reader, externalIDList);
        }
        else if (__context_tag == to_underlying(Fields::kData))
        {
            err = DataModel::Decode(reader, data);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace CancelRecordProgram.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::ChannelList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, channelList);
    case Attributes::Lineup::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, lineup);
    case Attributes::CurrentChannel::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentChannel);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace Channel
namespace TargetNavigator {
namespace Structs {

namespace TargetInfoStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kIdentifier), identifier);
    encoder.Encode(to_underlying(Fields::kName), name);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kIdentifier))
        {
            err = DataModel::Decode(reader, identifier);
        }
        else if (__context_tag == to_underlying(Fields::kName))
        {
            err = DataModel::Decode(reader, name);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace TargetInfoStruct
} // namespace Structs

namespace Commands {
namespace NavigateTarget {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kTarget), target);
    encoder.Encode(to_underlying(Fields::kData), data);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kTarget))
        {
            err = DataModel::Decode(reader, target);
        }
        else if (__context_tag == to_underlying(Fields::kData))
        {
            err = DataModel::Decode(reader, data);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace NavigateTarget.
namespace NavigateTargetResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kData), data);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kData))
        {
            err = DataModel::Decode(reader, data);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace NavigateTargetResponse.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::TargetList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, targetList);
    case Attributes::CurrentTarget::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentTarget);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace TargetUpdated {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kTargetList), targetList));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrentTarget), currentTarget));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kData), data));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kTargetList))
        {
            err = DataModel::Decode(reader, targetList);
        }
        else if (__context_tag == to_underlying(Fields::kCurrentTarget))
        {
            err = DataModel::Decode(reader, currentTarget);
        }
        else if (__context_tag == to_underlying(Fields::kData))
        {
            err = DataModel::Decode(reader, data);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TargetUpdated.
} // namespace Events

} // namespace TargetNavigator
namespace MediaPlayback {
namespace Structs {

namespace TrackAttributesStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kLanguageCode), languageCode);
    encoder.Encode(to_underlying(Fields::kDisplayName), displayName);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kLanguageCode))
        {
            err = DataModel::Decode(reader, languageCode);
        }
        else if (__context_tag == to_underlying(Fields::kDisplayName))
        {
            err = DataModel::Decode(reader, displayName);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace TrackAttributesStruct

namespace TrackStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kId), id);
    encoder.Encode(to_underlying(Fields::kTrackAttributes), trackAttributes);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kId))
        {
            err = DataModel::Decode(reader, id);
        }
        else if (__context_tag == to_underlying(Fields::kTrackAttributes))
        {
            err = DataModel::Decode(reader, trackAttributes);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace TrackStruct

namespace PlaybackPositionStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kUpdatedAt), updatedAt);
    encoder.Encode(to_underlying(Fields::kPosition), position);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kUpdatedAt))
        {
            err = DataModel::Decode(reader, updatedAt);
        }
        else if (__context_tag == to_underlying(Fields::kPosition))
        {
            err = DataModel::Decode(reader, position);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace PlaybackPositionStruct
} // namespace Structs

namespace Commands {
namespace Play {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace Play.
namespace Pause {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace Pause.
namespace Stop {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace Stop.
namespace StartOver {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace StartOver.
namespace Previous {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace Previous.
namespace Next {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace Next.
namespace Rewind {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kAudioAdvanceUnmuted), audioAdvanceUnmuted);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kAudioAdvanceUnmuted))
        {
            err = DataModel::Decode(reader, audioAdvanceUnmuted);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace Rewind.
namespace FastForward {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kAudioAdvanceUnmuted), audioAdvanceUnmuted);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kAudioAdvanceUnmuted))
        {
            err = DataModel::Decode(reader, audioAdvanceUnmuted);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace FastForward.
namespace SkipForward {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kDeltaPositionMilliseconds), deltaPositionMilliseconds);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kDeltaPositionMilliseconds))
        {
            err = DataModel::Decode(reader, deltaPositionMilliseconds);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SkipForward.
namespace SkipBackward {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kDeltaPositionMilliseconds), deltaPositionMilliseconds);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kDeltaPositionMilliseconds))
        {
            err = DataModel::Decode(reader, deltaPositionMilliseconds);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SkipBackward.
namespace PlaybackResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kData), data);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kData))
        {
            err = DataModel::Decode(reader, data);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace PlaybackResponse.
namespace Seek {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kPosition), position);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kPosition))
        {
            err = DataModel::Decode(reader, position);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace Seek.
namespace ActivateAudioTrack {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kTrackID), trackID);
    encoder.Encode(to_underlying(Fields::kAudioOutputIndex), audioOutputIndex);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kTrackID))
        {
            err = DataModel::Decode(reader, trackID);
        }
        else if (__context_tag == to_underlying(Fields::kAudioOutputIndex))
        {
            err = DataModel::Decode(reader, audioOutputIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ActivateAudioTrack.
namespace ActivateTextTrack {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kTrackID), trackID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kTrackID))
        {
            err = DataModel::Decode(reader, trackID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ActivateTextTrack.
namespace DeactivateTextTrack {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace DeactivateTextTrack.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::CurrentState::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentState);
    case Attributes::StartTime::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, startTime);
    case Attributes::Duration::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, duration);
    case Attributes::SampledPosition::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, sampledPosition);
    case Attributes::PlaybackSpeed::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, playbackSpeed);
    case Attributes::SeekRangeEnd::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, seekRangeEnd);
    case Attributes::SeekRangeStart::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, seekRangeStart);
    case Attributes::ActiveAudioTrack::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, activeAudioTrack);
    case Attributes::AvailableAudioTracks::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, availableAudioTracks);
    case Attributes::ActiveTextTrack::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, activeTextTrack);
    case Attributes::AvailableTextTracks::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, availableTextTracks);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace StateChanged {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrentState), currentState));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kStartTime), startTime));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kDuration), duration));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSampledPosition), sampledPosition));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPlaybackSpeed), playbackSpeed));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSeekRangeEnd), seekRangeEnd));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSeekRangeStart), seekRangeStart));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kData), data));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAudioAdvanceUnmuted), audioAdvanceUnmuted));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCurrentState))
        {
            err = DataModel::Decode(reader, currentState);
        }
        else if (__context_tag == to_underlying(Fields::kStartTime))
        {
            err = DataModel::Decode(reader, startTime);
        }
        else if (__context_tag == to_underlying(Fields::kDuration))
        {
            err = DataModel::Decode(reader, duration);
        }
        else if (__context_tag == to_underlying(Fields::kSampledPosition))
        {
            err = DataModel::Decode(reader, sampledPosition);
        }
        else if (__context_tag == to_underlying(Fields::kPlaybackSpeed))
        {
            err = DataModel::Decode(reader, playbackSpeed);
        }
        else if (__context_tag == to_underlying(Fields::kSeekRangeEnd))
        {
            err = DataModel::Decode(reader, seekRangeEnd);
        }
        else if (__context_tag == to_underlying(Fields::kSeekRangeStart))
        {
            err = DataModel::Decode(reader, seekRangeStart);
        }
        else if (__context_tag == to_underlying(Fields::kData))
        {
            err = DataModel::Decode(reader, data);
        }
        else if (__context_tag == to_underlying(Fields::kAudioAdvanceUnmuted))
        {
            err = DataModel::Decode(reader, audioAdvanceUnmuted);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace StateChanged.
} // namespace Events

} // namespace MediaPlayback
namespace MediaInput {
namespace Structs {

namespace InputInfoStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kIndex), index);
    encoder.Encode(to_underlying(Fields::kInputType), inputType);
    encoder.Encode(to_underlying(Fields::kName), name);
    encoder.Encode(to_underlying(Fields::kDescription), description);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kIndex))
        {
            err = DataModel::Decode(reader, index);
        }
        else if (__context_tag == to_underlying(Fields::kInputType))
        {
            err = DataModel::Decode(reader, inputType);
        }
        else if (__context_tag == to_underlying(Fields::kName))
        {
            err = DataModel::Decode(reader, name);
        }
        else if (__context_tag == to_underlying(Fields::kDescription))
        {
            err = DataModel::Decode(reader, description);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace InputInfoStruct
} // namespace Structs

namespace Commands {
namespace SelectInput {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kIndex), index);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kIndex))
        {
            err = DataModel::Decode(reader, index);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SelectInput.
namespace ShowInputStatus {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace ShowInputStatus.
namespace HideInputStatus {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace HideInputStatus.
namespace RenameInput {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kIndex), index);
    encoder.Encode(to_underlying(Fields::kName), name);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kIndex))
        {
            err = DataModel::Decode(reader, index);
        }
        else if (__context_tag == to_underlying(Fields::kName))
        {
            err = DataModel::Decode(reader, name);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace RenameInput.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::InputList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, inputList);
    case Attributes::CurrentInput::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentInput);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace MediaInput
namespace LowPower {

namespace Commands {
namespace Sleep {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace Sleep.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace LowPower
namespace KeypadInput {

namespace Commands {
namespace SendKey {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kKeyCode), keyCode);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kKeyCode))
        {
            err = DataModel::Decode(reader, keyCode);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SendKey.
namespace SendKeyResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStatus), status);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SendKeyResponse.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace KeypadInput
namespace ContentLauncher {
namespace Structs {

namespace DimensionStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kWidth), width);
    encoder.Encode(to_underlying(Fields::kHeight), height);
    encoder.Encode(to_underlying(Fields::kMetric), metric);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kWidth))
        {
            err = DataModel::Decode(reader, width);
        }
        else if (__context_tag == to_underlying(Fields::kHeight))
        {
            err = DataModel::Decode(reader, height);
        }
        else if (__context_tag == to_underlying(Fields::kMetric))
        {
            err = DataModel::Decode(reader, metric);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace DimensionStruct

namespace TrackPreferenceStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kLanguageCode), languageCode);
    encoder.Encode(to_underlying(Fields::kCharacteristics), characteristics);
    encoder.Encode(to_underlying(Fields::kAudioOutputIndex), audioOutputIndex);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kLanguageCode))
        {
            err = DataModel::Decode(reader, languageCode);
        }
        else if (__context_tag == to_underlying(Fields::kCharacteristics))
        {
            err = DataModel::Decode(reader, characteristics);
        }
        else if (__context_tag == to_underlying(Fields::kAudioOutputIndex))
        {
            err = DataModel::Decode(reader, audioOutputIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace TrackPreferenceStruct

namespace PlaybackPreferencesStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kPlaybackPosition), playbackPosition);
    encoder.Encode(to_underlying(Fields::kTextTrack), textTrack);
    encoder.Encode(to_underlying(Fields::kAudioTracks), audioTracks);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kPlaybackPosition))
        {
            err = DataModel::Decode(reader, playbackPosition);
        }
        else if (__context_tag == to_underlying(Fields::kTextTrack))
        {
            err = DataModel::Decode(reader, textTrack);
        }
        else if (__context_tag == to_underlying(Fields::kAudioTracks))
        {
            err = DataModel::Decode(reader, audioTracks);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace PlaybackPreferencesStruct

namespace AdditionalInfoStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kName), name);
    encoder.Encode(to_underlying(Fields::kValue), value);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kName))
        {
            err = DataModel::Decode(reader, name);
        }
        else if (__context_tag == to_underlying(Fields::kValue))
        {
            err = DataModel::Decode(reader, value);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace AdditionalInfoStruct

namespace ParameterStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kType), type);
    encoder.Encode(to_underlying(Fields::kValue), value);
    encoder.Encode(to_underlying(Fields::kExternalIDList), externalIDList);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kType))
        {
            err = DataModel::Decode(reader, type);
        }
        else if (__context_tag == to_underlying(Fields::kValue))
        {
            err = DataModel::Decode(reader, value);
        }
        else if (__context_tag == to_underlying(Fields::kExternalIDList))
        {
            err = DataModel::Decode(reader, externalIDList);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ParameterStruct

namespace ContentSearchStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kParameterList), parameterList);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kParameterList))
        {
            err = DataModel::Decode(reader, parameterList);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ContentSearchStruct

namespace StyleInformationStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kImageURL), imageURL);
    encoder.Encode(to_underlying(Fields::kColor), color);
    encoder.Encode(to_underlying(Fields::kSize), size);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kImageURL))
        {
            err = DataModel::Decode(reader, imageURL);
        }
        else if (__context_tag == to_underlying(Fields::kColor))
        {
            err = DataModel::Decode(reader, color);
        }
        else if (__context_tag == to_underlying(Fields::kSize))
        {
            err = DataModel::Decode(reader, size);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace StyleInformationStruct

namespace BrandingInformationStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kProviderName), providerName);
    encoder.Encode(to_underlying(Fields::kBackground), background);
    encoder.Encode(to_underlying(Fields::kLogo), logo);
    encoder.Encode(to_underlying(Fields::kProgressBar), progressBar);
    encoder.Encode(to_underlying(Fields::kSplash), splash);
    encoder.Encode(to_underlying(Fields::kWaterMark), waterMark);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kProviderName))
        {
            err = DataModel::Decode(reader, providerName);
        }
        else if (__context_tag == to_underlying(Fields::kBackground))
        {
            err = DataModel::Decode(reader, background);
        }
        else if (__context_tag == to_underlying(Fields::kLogo))
        {
            err = DataModel::Decode(reader, logo);
        }
        else if (__context_tag == to_underlying(Fields::kProgressBar))
        {
            err = DataModel::Decode(reader, progressBar);
        }
        else if (__context_tag == to_underlying(Fields::kSplash))
        {
            err = DataModel::Decode(reader, splash);
        }
        else if (__context_tag == to_underlying(Fields::kWaterMark))
        {
            err = DataModel::Decode(reader, waterMark);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace BrandingInformationStruct
} // namespace Structs

namespace Commands {
namespace LaunchContent {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kSearch), search);
    encoder.Encode(to_underlying(Fields::kAutoPlay), autoPlay);
    encoder.Encode(to_underlying(Fields::kData), data);
    encoder.Encode(to_underlying(Fields::kPlaybackPreferences), playbackPreferences);
    encoder.Encode(to_underlying(Fields::kUseCurrentContext), useCurrentContext);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kSearch))
        {
            err = DataModel::Decode(reader, search);
        }
        else if (__context_tag == to_underlying(Fields::kAutoPlay))
        {
            err = DataModel::Decode(reader, autoPlay);
        }
        else if (__context_tag == to_underlying(Fields::kData))
        {
            err = DataModel::Decode(reader, data);
        }
        else if (__context_tag == to_underlying(Fields::kPlaybackPreferences))
        {
            err = DataModel::Decode(reader, playbackPreferences);
        }
        else if (__context_tag == to_underlying(Fields::kUseCurrentContext))
        {
            err = DataModel::Decode(reader, useCurrentContext);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace LaunchContent.
namespace LaunchURL {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kContentURL), contentURL);
    encoder.Encode(to_underlying(Fields::kDisplayString), displayString);
    encoder.Encode(to_underlying(Fields::kBrandingInformation), brandingInformation);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kContentURL))
        {
            err = DataModel::Decode(reader, contentURL);
        }
        else if (__context_tag == to_underlying(Fields::kDisplayString))
        {
            err = DataModel::Decode(reader, displayString);
        }
        else if (__context_tag == to_underlying(Fields::kBrandingInformation))
        {
            err = DataModel::Decode(reader, brandingInformation);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace LaunchURL.
namespace LauncherResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kData), data);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kData))
        {
            err = DataModel::Decode(reader, data);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace LauncherResponse.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::AcceptHeader::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptHeader);
    case Attributes::SupportedStreamingProtocols::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, supportedStreamingProtocols);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace ContentLauncher
namespace AudioOutput {
namespace Structs {

namespace OutputInfoStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kIndex), index);
    encoder.Encode(to_underlying(Fields::kOutputType), outputType);
    encoder.Encode(to_underlying(Fields::kName), name);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kIndex))
        {
            err = DataModel::Decode(reader, index);
        }
        else if (__context_tag == to_underlying(Fields::kOutputType))
        {
            err = DataModel::Decode(reader, outputType);
        }
        else if (__context_tag == to_underlying(Fields::kName))
        {
            err = DataModel::Decode(reader, name);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace OutputInfoStruct
} // namespace Structs

namespace Commands {
namespace SelectOutput {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kIndex), index);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kIndex))
        {
            err = DataModel::Decode(reader, index);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SelectOutput.
namespace RenameOutput {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kIndex), index);
    encoder.Encode(to_underlying(Fields::kName), name);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kIndex))
        {
            err = DataModel::Decode(reader, index);
        }
        else if (__context_tag == to_underlying(Fields::kName))
        {
            err = DataModel::Decode(reader, name);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace RenameOutput.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::OutputList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, outputList);
    case Attributes::CurrentOutput::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentOutput);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace AudioOutput
namespace ApplicationLauncher {
namespace Structs {

namespace ApplicationEPStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kApplication), application);
    encoder.Encode(to_underlying(Fields::kEndpoint), endpoint);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kApplication))
        {
            err = DataModel::Decode(reader, application);
        }
        else if (__context_tag == to_underlying(Fields::kEndpoint))
        {
            err = DataModel::Decode(reader, endpoint);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ApplicationEPStruct
} // namespace Structs

namespace Commands {
namespace LaunchApp {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kApplication), application);
    encoder.Encode(to_underlying(Fields::kData), data);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kApplication))
        {
            err = DataModel::Decode(reader, application);
        }
        else if (__context_tag == to_underlying(Fields::kData))
        {
            err = DataModel::Decode(reader, data);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace LaunchApp.
namespace StopApp {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kApplication), application);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kApplication))
        {
            err = DataModel::Decode(reader, application);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace StopApp.
namespace HideApp {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kApplication), application);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kApplication))
        {
            err = DataModel::Decode(reader, application);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace HideApp.
namespace LauncherResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kData), data);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kData))
        {
            err = DataModel::Decode(reader, data);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace LauncherResponse.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::CatalogList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, catalogList);
    case Attributes::CurrentApp::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentApp);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace ApplicationLauncher
namespace ApplicationBasic {
namespace Structs {} // namespace Structs

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::VendorName::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, vendorName);
    case Attributes::VendorID::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, vendorID);
    case Attributes::ApplicationName::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, applicationName);
    case Attributes::ProductID::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, productID);
    case Attributes::Application::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, application);
    case Attributes::Status::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, status);
    case Attributes::ApplicationVersion::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, applicationVersion);
    case Attributes::AllowedVendorList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, allowedVendorList);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace ApplicationBasic
namespace AccountLogin {

namespace Commands {
namespace GetSetupPIN {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kTempAccountIdentifier), tempAccountIdentifier);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kTempAccountIdentifier))
        {
            err = DataModel::Decode(reader, tempAccountIdentifier);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GetSetupPIN.
namespace GetSetupPINResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kSetupPIN), setupPIN);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kSetupPIN))
        {
            err = DataModel::Decode(reader, setupPIN);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GetSetupPINResponse.
namespace Login {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kTempAccountIdentifier), tempAccountIdentifier);
    encoder.Encode(to_underlying(Fields::kSetupPIN), setupPIN);
    encoder.Encode(to_underlying(Fields::kNode), node);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kTempAccountIdentifier))
        {
            err = DataModel::Decode(reader, tempAccountIdentifier);
        }
        else if (__context_tag == to_underlying(Fields::kSetupPIN))
        {
            err = DataModel::Decode(reader, setupPIN);
        }
        else if (__context_tag == to_underlying(Fields::kNode))
        {
            err = DataModel::Decode(reader, node);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace Login.
namespace Logout {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kNode), node);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNode))
        {
            err = DataModel::Decode(reader, node);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace Logout.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace LoggedOut {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kNode), node));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNode))
        {
            err = DataModel::Decode(reader, node);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace LoggedOut.
} // namespace Events

} // namespace AccountLogin
namespace ContentControl {
namespace Structs {

namespace RatingNameStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kRatingName), ratingName);
    encoder.Encode(to_underlying(Fields::kRatingNameDesc), ratingNameDesc);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kRatingName))
        {
            err = DataModel::Decode(reader, ratingName);
        }
        else if (__context_tag == to_underlying(Fields::kRatingNameDesc))
        {
            err = DataModel::Decode(reader, ratingNameDesc);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace RatingNameStruct
} // namespace Structs

namespace Commands {
namespace UpdatePIN {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kOldPIN), oldPIN);
    encoder.Encode(to_underlying(Fields::kNewPIN), newPIN);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kOldPIN))
        {
            err = DataModel::Decode(reader, oldPIN);
        }
        else if (__context_tag == to_underlying(Fields::kNewPIN))
        {
            err = DataModel::Decode(reader, newPIN);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace UpdatePIN.
namespace ResetPIN {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace ResetPIN.
namespace ResetPINResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kPINCode), PINCode);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kPINCode))
        {
            err = DataModel::Decode(reader, PINCode);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ResetPINResponse.
namespace Enable {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace Enable.
namespace Disable {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace Disable.
namespace AddBonusTime {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kPINCode), PINCode);
    encoder.Encode(to_underlying(Fields::kBonusTime), bonusTime);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kPINCode))
        {
            err = DataModel::Decode(reader, PINCode);
        }
        else if (__context_tag == to_underlying(Fields::kBonusTime))
        {
            err = DataModel::Decode(reader, bonusTime);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace AddBonusTime.
namespace SetScreenDailyTime {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kScreenTime), screenTime);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kScreenTime))
        {
            err = DataModel::Decode(reader, screenTime);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetScreenDailyTime.
namespace BlockUnratedContent {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace BlockUnratedContent.
namespace UnblockUnratedContent {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace UnblockUnratedContent.
namespace SetOnDemandRatingThreshold {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kRating), rating);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kRating))
        {
            err = DataModel::Decode(reader, rating);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetOnDemandRatingThreshold.
namespace SetScheduledContentRatingThreshold {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kRating), rating);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kRating))
        {
            err = DataModel::Decode(reader, rating);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetScheduledContentRatingThreshold.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::Enabled::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, enabled);
    case Attributes::OnDemandRatings::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, onDemandRatings);
    case Attributes::OnDemandRatingThreshold::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, onDemandRatingThreshold);
    case Attributes::ScheduledContentRatings::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, scheduledContentRatings);
    case Attributes::ScheduledContentRatingThreshold::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, scheduledContentRatingThreshold);
    case Attributes::ScreenDailyTime::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, screenDailyTime);
    case Attributes::RemainingScreenTime::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, remainingScreenTime);
    case Attributes::BlockUnrated::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, blockUnrated);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace RemainingScreenTimeExpired {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace RemainingScreenTimeExpired.
} // namespace Events

} // namespace ContentControl
namespace ContentAppObserver {

namespace Commands {
namespace ContentAppMessage {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kData), data);
    encoder.Encode(to_underlying(Fields::kEncodingHint), encodingHint);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kData))
        {
            err = DataModel::Decode(reader, data);
        }
        else if (__context_tag == to_underlying(Fields::kEncodingHint))
        {
            err = DataModel::Decode(reader, encodingHint);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ContentAppMessage.
namespace ContentAppMessageResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStatus), status);
    encoder.Encode(to_underlying(Fields::kData), data);
    encoder.Encode(to_underlying(Fields::kEncodingHint), encodingHint);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStatus))
        {
            err = DataModel::Decode(reader, status);
        }
        else if (__context_tag == to_underlying(Fields::kData))
        {
            err = DataModel::Decode(reader, data);
        }
        else if (__context_tag == to_underlying(Fields::kEncodingHint))
        {
            err = DataModel::Decode(reader, encodingHint);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ContentAppMessageResponse.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace ContentAppObserver
namespace ZoneManagement {
namespace Structs {

namespace TwoDCartesianVertexStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kX), x);
    encoder.Encode(to_underlying(Fields::kY), y);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kX))
        {
            err = DataModel::Decode(reader, x);
        }
        else if (__context_tag == to_underlying(Fields::kY))
        {
            err = DataModel::Decode(reader, y);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace TwoDCartesianVertexStruct

namespace TwoDCartesianZoneStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kName), name);
    encoder.Encode(to_underlying(Fields::kUse), use);
    encoder.Encode(to_underlying(Fields::kVertices), vertices);
    encoder.Encode(to_underlying(Fields::kColor), color);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kName))
        {
            err = DataModel::Decode(reader, name);
        }
        else if (__context_tag == to_underlying(Fields::kUse))
        {
            err = DataModel::Decode(reader, use);
        }
        else if (__context_tag == to_underlying(Fields::kVertices))
        {
            err = DataModel::Decode(reader, vertices);
        }
        else if (__context_tag == to_underlying(Fields::kColor))
        {
            err = DataModel::Decode(reader, color);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace TwoDCartesianZoneStruct

namespace ZoneInformationStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kZoneID), zoneID);
    encoder.Encode(to_underlying(Fields::kZoneType), zoneType);
    encoder.Encode(to_underlying(Fields::kZoneSource), zoneSource);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kZoneID))
        {
            err = DataModel::Decode(reader, zoneID);
        }
        else if (__context_tag == to_underlying(Fields::kZoneType))
        {
            err = DataModel::Decode(reader, zoneType);
        }
        else if (__context_tag == to_underlying(Fields::kZoneSource))
        {
            err = DataModel::Decode(reader, zoneSource);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ZoneInformationStruct

namespace ZoneTriggeringTimeControlStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kInitialDuration), initialDuration);
    encoder.Encode(to_underlying(Fields::kAugmentationDuration), augmentationDuration);
    encoder.Encode(to_underlying(Fields::kMaxDuration), maxDuration);
    encoder.Encode(to_underlying(Fields::kBlindDuration), blindDuration);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kInitialDuration))
        {
            err = DataModel::Decode(reader, initialDuration);
        }
        else if (__context_tag == to_underlying(Fields::kAugmentationDuration))
        {
            err = DataModel::Decode(reader, augmentationDuration);
        }
        else if (__context_tag == to_underlying(Fields::kMaxDuration))
        {
            err = DataModel::Decode(reader, maxDuration);
        }
        else if (__context_tag == to_underlying(Fields::kBlindDuration))
        {
            err = DataModel::Decode(reader, blindDuration);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ZoneTriggeringTimeControlStruct
} // namespace Structs

namespace Commands {
namespace CreateTwoDCartesianZone {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kZone), zone);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kZone))
        {
            err = DataModel::Decode(reader, zone);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace CreateTwoDCartesianZone.
namespace CreateTwoDCartesianZoneResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kZoneID), zoneID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kZoneID))
        {
            err = DataModel::Decode(reader, zoneID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace CreateTwoDCartesianZoneResponse.
namespace UpdateTwoDCartesianZone {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kZoneID), zoneID);
    encoder.Encode(to_underlying(Fields::kZone), zone);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kZoneID))
        {
            err = DataModel::Decode(reader, zoneID);
        }
        else if (__context_tag == to_underlying(Fields::kZone))
        {
            err = DataModel::Decode(reader, zone);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace UpdateTwoDCartesianZone.
namespace GetTwoDCartesianZone {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kZoneID), zoneID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kZoneID))
        {
            err = DataModel::Decode(reader, zoneID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GetTwoDCartesianZone.
namespace GetTwoDCartesianZoneResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kZones), zones);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kZones))
        {
            err = DataModel::Decode(reader, zones);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GetTwoDCartesianZoneResponse.
namespace RemoveZone {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kZoneID), zoneID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kZoneID))
        {
            err = DataModel::Decode(reader, zoneID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace RemoveZone.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::SupportedZoneSources::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, supportedZoneSources);
    case Attributes::Zones::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, zones);
    case Attributes::TimeControl::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, timeControl);
    case Attributes::Sensitivity::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, sensitivity);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace ZoneTriggered {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kZones), zones));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kReason), reason));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kZones))
        {
            err = DataModel::Decode(reader, zones);
        }
        else if (__context_tag == to_underlying(Fields::kReason))
        {
            err = DataModel::Decode(reader, reason);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ZoneTriggered.
namespace ZoneStopped {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kZones), zones));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kReason), reason));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kZones))
        {
            err = DataModel::Decode(reader, zones);
        }
        else if (__context_tag == to_underlying(Fields::kReason))
        {
            err = DataModel::Decode(reader, reason);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ZoneStopped.
} // namespace Events

} // namespace ZoneManagement
namespace CameraAvStreamManagement {
namespace Structs {

namespace VideoResolutionStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kWidth), width);
    encoder.Encode(to_underlying(Fields::kHeight), height);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kWidth))
        {
            err = DataModel::Decode(reader, width);
        }
        else if (__context_tag == to_underlying(Fields::kHeight))
        {
            err = DataModel::Decode(reader, height);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace VideoResolutionStruct

namespace VideoStreamStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kVideoStreamID), videoStreamID);
    encoder.Encode(to_underlying(Fields::kStreamType), streamType);
    encoder.Encode(to_underlying(Fields::kVideoCodec), videoCodec);
    encoder.Encode(to_underlying(Fields::kMinFrameRate), minFrameRate);
    encoder.Encode(to_underlying(Fields::kMaxFrameRate), maxFrameRate);
    encoder.Encode(to_underlying(Fields::kMinResolution), minResolution);
    encoder.Encode(to_underlying(Fields::kMaxResolution), maxResolution);
    encoder.Encode(to_underlying(Fields::kMinBitRate), minBitRate);
    encoder.Encode(to_underlying(Fields::kMaxBitRate), maxBitRate);
    encoder.Encode(to_underlying(Fields::kMinFragmentLen), minFragmentLen);
    encoder.Encode(to_underlying(Fields::kMaxFragmentLen), maxFragmentLen);
    encoder.Encode(to_underlying(Fields::kWatermarkEnabled), watermarkEnabled);
    encoder.Encode(to_underlying(Fields::kOSDEnabled), OSDEnabled);
    encoder.Encode(to_underlying(Fields::kReferenceCount), referenceCount);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kVideoStreamID))
        {
            err = DataModel::Decode(reader, videoStreamID);
        }
        else if (__context_tag == to_underlying(Fields::kStreamType))
        {
            err = DataModel::Decode(reader, streamType);
        }
        else if (__context_tag == to_underlying(Fields::kVideoCodec))
        {
            err = DataModel::Decode(reader, videoCodec);
        }
        else if (__context_tag == to_underlying(Fields::kMinFrameRate))
        {
            err = DataModel::Decode(reader, minFrameRate);
        }
        else if (__context_tag == to_underlying(Fields::kMaxFrameRate))
        {
            err = DataModel::Decode(reader, maxFrameRate);
        }
        else if (__context_tag == to_underlying(Fields::kMinResolution))
        {
            err = DataModel::Decode(reader, minResolution);
        }
        else if (__context_tag == to_underlying(Fields::kMaxResolution))
        {
            err = DataModel::Decode(reader, maxResolution);
        }
        else if (__context_tag == to_underlying(Fields::kMinBitRate))
        {
            err = DataModel::Decode(reader, minBitRate);
        }
        else if (__context_tag == to_underlying(Fields::kMaxBitRate))
        {
            err = DataModel::Decode(reader, maxBitRate);
        }
        else if (__context_tag == to_underlying(Fields::kMinFragmentLen))
        {
            err = DataModel::Decode(reader, minFragmentLen);
        }
        else if (__context_tag == to_underlying(Fields::kMaxFragmentLen))
        {
            err = DataModel::Decode(reader, maxFragmentLen);
        }
        else if (__context_tag == to_underlying(Fields::kWatermarkEnabled))
        {
            err = DataModel::Decode(reader, watermarkEnabled);
        }
        else if (__context_tag == to_underlying(Fields::kOSDEnabled))
        {
            err = DataModel::Decode(reader, OSDEnabled);
        }
        else if (__context_tag == to_underlying(Fields::kReferenceCount))
        {
            err = DataModel::Decode(reader, referenceCount);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace VideoStreamStruct

namespace SnapshotStreamStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kSnapshotStreamID), snapshotStreamID);
    encoder.Encode(to_underlying(Fields::kImageCodec), imageCodec);
    encoder.Encode(to_underlying(Fields::kFrameRate), frameRate);
    encoder.Encode(to_underlying(Fields::kBitRate), bitRate);
    encoder.Encode(to_underlying(Fields::kMinResolution), minResolution);
    encoder.Encode(to_underlying(Fields::kMaxResolution), maxResolution);
    encoder.Encode(to_underlying(Fields::kQuality), quality);
    encoder.Encode(to_underlying(Fields::kReferenceCount), referenceCount);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kSnapshotStreamID))
        {
            err = DataModel::Decode(reader, snapshotStreamID);
        }
        else if (__context_tag == to_underlying(Fields::kImageCodec))
        {
            err = DataModel::Decode(reader, imageCodec);
        }
        else if (__context_tag == to_underlying(Fields::kFrameRate))
        {
            err = DataModel::Decode(reader, frameRate);
        }
        else if (__context_tag == to_underlying(Fields::kBitRate))
        {
            err = DataModel::Decode(reader, bitRate);
        }
        else if (__context_tag == to_underlying(Fields::kMinResolution))
        {
            err = DataModel::Decode(reader, minResolution);
        }
        else if (__context_tag == to_underlying(Fields::kMaxResolution))
        {
            err = DataModel::Decode(reader, maxResolution);
        }
        else if (__context_tag == to_underlying(Fields::kQuality))
        {
            err = DataModel::Decode(reader, quality);
        }
        else if (__context_tag == to_underlying(Fields::kReferenceCount))
        {
            err = DataModel::Decode(reader, referenceCount);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace SnapshotStreamStruct

namespace SnapshotParamsStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kResolution), resolution);
    encoder.Encode(to_underlying(Fields::kMaxFrameRate), maxFrameRate);
    encoder.Encode(to_underlying(Fields::kImageCodec), imageCodec);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kResolution))
        {
            err = DataModel::Decode(reader, resolution);
        }
        else if (__context_tag == to_underlying(Fields::kMaxFrameRate))
        {
            err = DataModel::Decode(reader, maxFrameRate);
        }
        else if (__context_tag == to_underlying(Fields::kImageCodec))
        {
            err = DataModel::Decode(reader, imageCodec);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace SnapshotParamsStruct

namespace RateDistortionTradeOffPointsStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kCodec), codec);
    encoder.Encode(to_underlying(Fields::kResolution), resolution);
    encoder.Encode(to_underlying(Fields::kMinBitRate), minBitRate);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCodec))
        {
            err = DataModel::Decode(reader, codec);
        }
        else if (__context_tag == to_underlying(Fields::kResolution))
        {
            err = DataModel::Decode(reader, resolution);
        }
        else if (__context_tag == to_underlying(Fields::kMinBitRate))
        {
            err = DataModel::Decode(reader, minBitRate);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace RateDistortionTradeOffPointsStruct

namespace AudioCapabilitiesStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kMaxNumberOfChannels), maxNumberOfChannels);
    encoder.Encode(to_underlying(Fields::kSupportedCodecs), supportedCodecs);
    encoder.Encode(to_underlying(Fields::kSupportedSampleRates), supportedSampleRates);
    encoder.Encode(to_underlying(Fields::kSupportedBitDepths), supportedBitDepths);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kMaxNumberOfChannels))
        {
            err = DataModel::Decode(reader, maxNumberOfChannels);
        }
        else if (__context_tag == to_underlying(Fields::kSupportedCodecs))
        {
            err = DataModel::Decode(reader, supportedCodecs);
        }
        else if (__context_tag == to_underlying(Fields::kSupportedSampleRates))
        {
            err = DataModel::Decode(reader, supportedSampleRates);
        }
        else if (__context_tag == to_underlying(Fields::kSupportedBitDepths))
        {
            err = DataModel::Decode(reader, supportedBitDepths);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace AudioCapabilitiesStruct

namespace AudioStreamStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kAudioStreamID), audioStreamID);
    encoder.Encode(to_underlying(Fields::kStreamType), streamType);
    encoder.Encode(to_underlying(Fields::kAudioCodec), audioCodec);
    encoder.Encode(to_underlying(Fields::kChannelCount), channelCount);
    encoder.Encode(to_underlying(Fields::kSampleRate), sampleRate);
    encoder.Encode(to_underlying(Fields::kBitRate), bitRate);
    encoder.Encode(to_underlying(Fields::kBitDepth), bitDepth);
    encoder.Encode(to_underlying(Fields::kReferenceCount), referenceCount);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kAudioStreamID))
        {
            err = DataModel::Decode(reader, audioStreamID);
        }
        else if (__context_tag == to_underlying(Fields::kStreamType))
        {
            err = DataModel::Decode(reader, streamType);
        }
        else if (__context_tag == to_underlying(Fields::kAudioCodec))
        {
            err = DataModel::Decode(reader, audioCodec);
        }
        else if (__context_tag == to_underlying(Fields::kChannelCount))
        {
            err = DataModel::Decode(reader, channelCount);
        }
        else if (__context_tag == to_underlying(Fields::kSampleRate))
        {
            err = DataModel::Decode(reader, sampleRate);
        }
        else if (__context_tag == to_underlying(Fields::kBitRate))
        {
            err = DataModel::Decode(reader, bitRate);
        }
        else if (__context_tag == to_underlying(Fields::kBitDepth))
        {
            err = DataModel::Decode(reader, bitDepth);
        }
        else if (__context_tag == to_underlying(Fields::kReferenceCount))
        {
            err = DataModel::Decode(reader, referenceCount);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace AudioStreamStruct

namespace VideoSensorParamsStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kSensorWidth), sensorWidth);
    encoder.Encode(to_underlying(Fields::kSensorHeight), sensorHeight);
    encoder.Encode(to_underlying(Fields::kHDRCapable), HDRCapable);
    encoder.Encode(to_underlying(Fields::kMaxFPS), maxFPS);
    encoder.Encode(to_underlying(Fields::kMaxHDRFPS), maxHDRFPS);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kSensorWidth))
        {
            err = DataModel::Decode(reader, sensorWidth);
        }
        else if (__context_tag == to_underlying(Fields::kSensorHeight))
        {
            err = DataModel::Decode(reader, sensorHeight);
        }
        else if (__context_tag == to_underlying(Fields::kHDRCapable))
        {
            err = DataModel::Decode(reader, HDRCapable);
        }
        else if (__context_tag == to_underlying(Fields::kMaxFPS))
        {
            err = DataModel::Decode(reader, maxFPS);
        }
        else if (__context_tag == to_underlying(Fields::kMaxHDRFPS))
        {
            err = DataModel::Decode(reader, maxHDRFPS);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace VideoSensorParamsStruct
} // namespace Structs

namespace Commands {
namespace AudioStreamAllocate {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStreamType), streamType);
    encoder.Encode(to_underlying(Fields::kAudioCodec), audioCodec);
    encoder.Encode(to_underlying(Fields::kChannelCount), channelCount);
    encoder.Encode(to_underlying(Fields::kSampleRate), sampleRate);
    encoder.Encode(to_underlying(Fields::kBitRate), bitRate);
    encoder.Encode(to_underlying(Fields::kBitDepth), bitDepth);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStreamType))
        {
            err = DataModel::Decode(reader, streamType);
        }
        else if (__context_tag == to_underlying(Fields::kAudioCodec))
        {
            err = DataModel::Decode(reader, audioCodec);
        }
        else if (__context_tag == to_underlying(Fields::kChannelCount))
        {
            err = DataModel::Decode(reader, channelCount);
        }
        else if (__context_tag == to_underlying(Fields::kSampleRate))
        {
            err = DataModel::Decode(reader, sampleRate);
        }
        else if (__context_tag == to_underlying(Fields::kBitRate))
        {
            err = DataModel::Decode(reader, bitRate);
        }
        else if (__context_tag == to_underlying(Fields::kBitDepth))
        {
            err = DataModel::Decode(reader, bitDepth);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace AudioStreamAllocate.
namespace AudioStreamAllocateResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kAudioStreamID), audioStreamID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kAudioStreamID))
        {
            err = DataModel::Decode(reader, audioStreamID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace AudioStreamAllocateResponse.
namespace AudioStreamDeallocate {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kAudioStreamID), audioStreamID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kAudioStreamID))
        {
            err = DataModel::Decode(reader, audioStreamID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace AudioStreamDeallocate.
namespace VideoStreamAllocate {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStreamType), streamType);
    encoder.Encode(to_underlying(Fields::kVideoCodec), videoCodec);
    encoder.Encode(to_underlying(Fields::kMinFrameRate), minFrameRate);
    encoder.Encode(to_underlying(Fields::kMaxFrameRate), maxFrameRate);
    encoder.Encode(to_underlying(Fields::kMinResolution), minResolution);
    encoder.Encode(to_underlying(Fields::kMaxResolution), maxResolution);
    encoder.Encode(to_underlying(Fields::kMinBitRate), minBitRate);
    encoder.Encode(to_underlying(Fields::kMaxBitRate), maxBitRate);
    encoder.Encode(to_underlying(Fields::kMinFragmentLen), minFragmentLen);
    encoder.Encode(to_underlying(Fields::kMaxFragmentLen), maxFragmentLen);
    encoder.Encode(to_underlying(Fields::kWatermarkEnabled), watermarkEnabled);
    encoder.Encode(to_underlying(Fields::kOSDEnabled), OSDEnabled);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStreamType))
        {
            err = DataModel::Decode(reader, streamType);
        }
        else if (__context_tag == to_underlying(Fields::kVideoCodec))
        {
            err = DataModel::Decode(reader, videoCodec);
        }
        else if (__context_tag == to_underlying(Fields::kMinFrameRate))
        {
            err = DataModel::Decode(reader, minFrameRate);
        }
        else if (__context_tag == to_underlying(Fields::kMaxFrameRate))
        {
            err = DataModel::Decode(reader, maxFrameRate);
        }
        else if (__context_tag == to_underlying(Fields::kMinResolution))
        {
            err = DataModel::Decode(reader, minResolution);
        }
        else if (__context_tag == to_underlying(Fields::kMaxResolution))
        {
            err = DataModel::Decode(reader, maxResolution);
        }
        else if (__context_tag == to_underlying(Fields::kMinBitRate))
        {
            err = DataModel::Decode(reader, minBitRate);
        }
        else if (__context_tag == to_underlying(Fields::kMaxBitRate))
        {
            err = DataModel::Decode(reader, maxBitRate);
        }
        else if (__context_tag == to_underlying(Fields::kMinFragmentLen))
        {
            err = DataModel::Decode(reader, minFragmentLen);
        }
        else if (__context_tag == to_underlying(Fields::kMaxFragmentLen))
        {
            err = DataModel::Decode(reader, maxFragmentLen);
        }
        else if (__context_tag == to_underlying(Fields::kWatermarkEnabled))
        {
            err = DataModel::Decode(reader, watermarkEnabled);
        }
        else if (__context_tag == to_underlying(Fields::kOSDEnabled))
        {
            err = DataModel::Decode(reader, OSDEnabled);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace VideoStreamAllocate.
namespace VideoStreamAllocateResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kVideoStreamID), videoStreamID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kVideoStreamID))
        {
            err = DataModel::Decode(reader, videoStreamID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace VideoStreamAllocateResponse.
namespace VideoStreamModify {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kVideoStreamID), videoStreamID);
    encoder.Encode(to_underlying(Fields::kResolution), resolution);
    encoder.Encode(to_underlying(Fields::kWatermarkEnabled), watermarkEnabled);
    encoder.Encode(to_underlying(Fields::kOSDEnabled), OSDEnabled);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kVideoStreamID))
        {
            err = DataModel::Decode(reader, videoStreamID);
        }
        else if (__context_tag == to_underlying(Fields::kResolution))
        {
            err = DataModel::Decode(reader, resolution);
        }
        else if (__context_tag == to_underlying(Fields::kWatermarkEnabled))
        {
            err = DataModel::Decode(reader, watermarkEnabled);
        }
        else if (__context_tag == to_underlying(Fields::kOSDEnabled))
        {
            err = DataModel::Decode(reader, OSDEnabled);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace VideoStreamModify.
namespace VideoStreamDeallocate {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kVideoStreamID), videoStreamID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kVideoStreamID))
        {
            err = DataModel::Decode(reader, videoStreamID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace VideoStreamDeallocate.
namespace SnapshotStreamAllocate {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kImageCodec), imageCodec);
    encoder.Encode(to_underlying(Fields::kFrameRate), frameRate);
    encoder.Encode(to_underlying(Fields::kBitRate), bitRate);
    encoder.Encode(to_underlying(Fields::kMinResolution), minResolution);
    encoder.Encode(to_underlying(Fields::kMaxResolution), maxResolution);
    encoder.Encode(to_underlying(Fields::kQuality), quality);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kImageCodec))
        {
            err = DataModel::Decode(reader, imageCodec);
        }
        else if (__context_tag == to_underlying(Fields::kFrameRate))
        {
            err = DataModel::Decode(reader, frameRate);
        }
        else if (__context_tag == to_underlying(Fields::kBitRate))
        {
            err = DataModel::Decode(reader, bitRate);
        }
        else if (__context_tag == to_underlying(Fields::kMinResolution))
        {
            err = DataModel::Decode(reader, minResolution);
        }
        else if (__context_tag == to_underlying(Fields::kMaxResolution))
        {
            err = DataModel::Decode(reader, maxResolution);
        }
        else if (__context_tag == to_underlying(Fields::kQuality))
        {
            err = DataModel::Decode(reader, quality);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SnapshotStreamAllocate.
namespace SnapshotStreamAllocateResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kSnapshotStreamID), snapshotStreamID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kSnapshotStreamID))
        {
            err = DataModel::Decode(reader, snapshotStreamID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SnapshotStreamAllocateResponse.
namespace SnapshotStreamDeallocate {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kSnapshotStreamID), snapshotStreamID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kSnapshotStreamID))
        {
            err = DataModel::Decode(reader, snapshotStreamID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SnapshotStreamDeallocate.
namespace SetStreamPriorities {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStreamPriorities), streamPriorities);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStreamPriorities))
        {
            err = DataModel::Decode(reader, streamPriorities);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetStreamPriorities.
namespace CaptureSnapshot {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kSnapshotStreamID), snapshotStreamID);
    encoder.Encode(to_underlying(Fields::kRequestedResolution), requestedResolution);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kSnapshotStreamID))
        {
            err = DataModel::Decode(reader, snapshotStreamID);
        }
        else if (__context_tag == to_underlying(Fields::kRequestedResolution))
        {
            err = DataModel::Decode(reader, requestedResolution);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace CaptureSnapshot.
namespace CaptureSnapshotResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kData), data);
    encoder.Encode(to_underlying(Fields::kImageCodec), imageCodec);
    encoder.Encode(to_underlying(Fields::kResolution), resolution);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kData))
        {
            err = DataModel::Decode(reader, data);
        }
        else if (__context_tag == to_underlying(Fields::kImageCodec))
        {
            err = DataModel::Decode(reader, imageCodec);
        }
        else if (__context_tag == to_underlying(Fields::kResolution))
        {
            err = DataModel::Decode(reader, resolution);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace CaptureSnapshotResponse.
namespace SetViewport {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kViewport), viewport);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kViewport))
        {
            err = DataModel::Decode(reader, viewport);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetViewport.
namespace SetImageRotation {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kAngle), angle);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kAngle))
        {
            err = DataModel::Decode(reader, angle);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetImageRotation.
namespace SetImageFlipHorizontal {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kEnabled), enabled);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kEnabled))
        {
            err = DataModel::Decode(reader, enabled);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetImageFlipHorizontal.
namespace SetImageFlipVertical {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kEnabled), enabled);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kEnabled))
        {
            err = DataModel::Decode(reader, enabled);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SetImageFlipVertical.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::MaxConcurrentVideoEncoders::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxConcurrentVideoEncoders);
    case Attributes::MaxEncodedPixelRate::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxEncodedPixelRate);
    case Attributes::VideoSensorParams::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, videoSensorParams);
    case Attributes::NightVisionCapable::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nightVisionCapable);
    case Attributes::MinViewport::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, minViewport);
    case Attributes::RateDistortionTradeOffPoints::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, rateDistortionTradeOffPoints);
    case Attributes::MaxPreRollBufferSize::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxPreRollBufferSize);
    case Attributes::MicrophoneCapabilities::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, microphoneCapabilities);
    case Attributes::SpeakerCapabilities::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, speakerCapabilities);
    case Attributes::TwoWayTalkSupport::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, twoWayTalkSupport);
    case Attributes::SupportedSnapshotParams::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, supportedSnapshotParams);
    case Attributes::MaxNetworkBandwidth::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, maxNetworkBandwidth);
    case Attributes::CurrentFrameRate::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentFrameRate);
    case Attributes::HDRModeEnabled::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, HDRModeEnabled);
    case Attributes::CurrentVideoCodecs::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentVideoCodecs);
    case Attributes::CurrentSnapshotConfig::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentSnapshotConfig);
    case Attributes::FabricsUsingCamera::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, fabricsUsingCamera);
    case Attributes::AllocatedVideoStreams::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, allocatedVideoStreams);
    case Attributes::AllocatedAudioStreams::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, allocatedAudioStreams);
    case Attributes::AllocatedSnapshotStreams::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, allocatedSnapshotStreams);
    case Attributes::RankedVideoStreamPrioritiesList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, rankedVideoStreamPrioritiesList);
    case Attributes::SoftRecordingPrivacyModeEnabled::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, softRecordingPrivacyModeEnabled);
    case Attributes::SoftLivestreamPrivacyModeEnabled::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, softLivestreamPrivacyModeEnabled);
    case Attributes::HardPrivacyModeOn::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, hardPrivacyModeOn);
    case Attributes::NightVision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nightVision);
    case Attributes::NightVisionIllum::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nightVisionIllum);
    case Attributes::AWBEnabled::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, AWBEnabled);
    case Attributes::AutoShutterSpeedEnabled::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, autoShutterSpeedEnabled);
    case Attributes::AutoISOEnabled::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, autoISOEnabled);
    case Attributes::Viewport::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, viewport);
    case Attributes::SpeakerMuted::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, speakerMuted);
    case Attributes::SpeakerVolumeLevel::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, speakerVolumeLevel);
    case Attributes::SpeakerMaxLevel::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, speakerMaxLevel);
    case Attributes::SpeakerMinLevel::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, speakerMinLevel);
    case Attributes::MicrophoneMuted::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, microphoneMuted);
    case Attributes::MicrophoneVolumeLevel::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, microphoneVolumeLevel);
    case Attributes::MicrophoneMaxLevel::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, microphoneMaxLevel);
    case Attributes::MicrophoneMinLevel::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, microphoneMinLevel);
    case Attributes::MicrophoneAGCEnabled::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, microphoneAGCEnabled);
    case Attributes::ImageRotation::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, imageRotation);
    case Attributes::ImageFlipHorizontal::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, imageFlipHorizontal);
    case Attributes::ImageFlipVertical::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, imageFlipVertical);
    case Attributes::LocalVideoRecordingEnabled::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, localVideoRecordingEnabled);
    case Attributes::LocalSnapshotRecordingEnabled::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, localSnapshotRecordingEnabled);
    case Attributes::StatusLightEnabled::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, statusLightEnabled);
    case Attributes::StatusLightBrightness::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, statusLightBrightness);
    case Attributes::DepthSensorStatus::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, depthSensorStatus);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace VideoStreamChanged {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kVideoStreamID), videoStreamID));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kStreamType), streamType));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kVideoCodec), videoCodec));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMinFrameRate), minFrameRate));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMaxFrameRate), maxFrameRate));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMinResolution), minResolution));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMaxResolution), maxResolution));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMinBitRate), minBitRate));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMaxBitRate), maxBitRate));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMinFragmentLen), minFragmentLen));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMaxFragmentLen), maxFragmentLen));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kVideoStreamID))
        {
            err = DataModel::Decode(reader, videoStreamID);
        }
        else if (__context_tag == to_underlying(Fields::kStreamType))
        {
            err = DataModel::Decode(reader, streamType);
        }
        else if (__context_tag == to_underlying(Fields::kVideoCodec))
        {
            err = DataModel::Decode(reader, videoCodec);
        }
        else if (__context_tag == to_underlying(Fields::kMinFrameRate))
        {
            err = DataModel::Decode(reader, minFrameRate);
        }
        else if (__context_tag == to_underlying(Fields::kMaxFrameRate))
        {
            err = DataModel::Decode(reader, maxFrameRate);
        }
        else if (__context_tag == to_underlying(Fields::kMinResolution))
        {
            err = DataModel::Decode(reader, minResolution);
        }
        else if (__context_tag == to_underlying(Fields::kMaxResolution))
        {
            err = DataModel::Decode(reader, maxResolution);
        }
        else if (__context_tag == to_underlying(Fields::kMinBitRate))
        {
            err = DataModel::Decode(reader, minBitRate);
        }
        else if (__context_tag == to_underlying(Fields::kMaxBitRate))
        {
            err = DataModel::Decode(reader, maxBitRate);
        }
        else if (__context_tag == to_underlying(Fields::kMinFragmentLen))
        {
            err = DataModel::Decode(reader, minFragmentLen);
        }
        else if (__context_tag == to_underlying(Fields::kMaxFragmentLen))
        {
            err = DataModel::Decode(reader, maxFragmentLen);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace VideoStreamChanged.
namespace AudioStreamChanged {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAudioStreamID), audioStreamID));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kStreamType), streamType));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAudioCodec), audioCodec));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kChannelCount), channelCount));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSampleRate), sampleRate));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kBitRate), bitRate));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kBitDepth), bitDepth));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kAudioStreamID))
        {
            err = DataModel::Decode(reader, audioStreamID);
        }
        else if (__context_tag == to_underlying(Fields::kStreamType))
        {
            err = DataModel::Decode(reader, streamType);
        }
        else if (__context_tag == to_underlying(Fields::kAudioCodec))
        {
            err = DataModel::Decode(reader, audioCodec);
        }
        else if (__context_tag == to_underlying(Fields::kChannelCount))
        {
            err = DataModel::Decode(reader, channelCount);
        }
        else if (__context_tag == to_underlying(Fields::kSampleRate))
        {
            err = DataModel::Decode(reader, sampleRate);
        }
        else if (__context_tag == to_underlying(Fields::kBitRate))
        {
            err = DataModel::Decode(reader, bitRate);
        }
        else if (__context_tag == to_underlying(Fields::kBitDepth))
        {
            err = DataModel::Decode(reader, bitDepth);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace AudioStreamChanged.
namespace SnapshotStreamChanged {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSnapshotStreamID), snapshotStreamID));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kImageCodec), imageCodec));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kFrameRate), frameRate));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kBitRate), bitRate));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMinResolution), minResolution));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMaxResolution), maxResolution));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kQuality), quality));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kSnapshotStreamID))
        {
            err = DataModel::Decode(reader, snapshotStreamID);
        }
        else if (__context_tag == to_underlying(Fields::kImageCodec))
        {
            err = DataModel::Decode(reader, imageCodec);
        }
        else if (__context_tag == to_underlying(Fields::kFrameRate))
        {
            err = DataModel::Decode(reader, frameRate);
        }
        else if (__context_tag == to_underlying(Fields::kBitRate))
        {
            err = DataModel::Decode(reader, bitRate);
        }
        else if (__context_tag == to_underlying(Fields::kMinResolution))
        {
            err = DataModel::Decode(reader, minResolution);
        }
        else if (__context_tag == to_underlying(Fields::kMaxResolution))
        {
            err = DataModel::Decode(reader, maxResolution);
        }
        else if (__context_tag == to_underlying(Fields::kQuality))
        {
            err = DataModel::Decode(reader, quality);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SnapshotStreamChanged.
} // namespace Events

} // namespace CameraAvStreamManagement
namespace WebRTCTransportProvider {
namespace Structs {} // namespace Structs

namespace Commands {
namespace SolicitOffer {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kStreamType), streamType);
    encoder.Encode(to_underlying(Fields::kVideoStreamID), videoStreamID);
    encoder.Encode(to_underlying(Fields::kAudioStreamID), audioStreamID);
    encoder.Encode(to_underlying(Fields::kICEServers), ICEServers);
    encoder.Encode(to_underlying(Fields::kICETransportPolicy), ICETransportPolicy);
    encoder.Encode(to_underlying(Fields::kMetadataOptions), metadataOptions);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kStreamType))
        {
            err = DataModel::Decode(reader, streamType);
        }
        else if (__context_tag == to_underlying(Fields::kVideoStreamID))
        {
            err = DataModel::Decode(reader, videoStreamID);
        }
        else if (__context_tag == to_underlying(Fields::kAudioStreamID))
        {
            err = DataModel::Decode(reader, audioStreamID);
        }
        else if (__context_tag == to_underlying(Fields::kICEServers))
        {
            err = DataModel::Decode(reader, ICEServers);
        }
        else if (__context_tag == to_underlying(Fields::kICETransportPolicy))
        {
            err = DataModel::Decode(reader, ICETransportPolicy);
        }
        else if (__context_tag == to_underlying(Fields::kMetadataOptions))
        {
            err = DataModel::Decode(reader, metadataOptions);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SolicitOffer.
namespace SolicitOfferResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kWebRTCSessionID), webRTCSessionID);
    encoder.Encode(to_underlying(Fields::kDeferredOffer), deferredOffer);
    encoder.Encode(to_underlying(Fields::kVideoStreamID), videoStreamID);
    encoder.Encode(to_underlying(Fields::kAudioStreamID), audioStreamID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kWebRTCSessionID))
        {
            err = DataModel::Decode(reader, webRTCSessionID);
        }
        else if (__context_tag == to_underlying(Fields::kDeferredOffer))
        {
            err = DataModel::Decode(reader, deferredOffer);
        }
        else if (__context_tag == to_underlying(Fields::kVideoStreamID))
        {
            err = DataModel::Decode(reader, videoStreamID);
        }
        else if (__context_tag == to_underlying(Fields::kAudioStreamID))
        {
            err = DataModel::Decode(reader, audioStreamID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SolicitOfferResponse.
namespace ProvideOffer {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kWebRTCSessionID), webRTCSessionID);
    encoder.Encode(to_underlying(Fields::kSdp), sdp);
    encoder.Encode(to_underlying(Fields::kStreamType), streamType);
    encoder.Encode(to_underlying(Fields::kVideoStreamID), videoStreamID);
    encoder.Encode(to_underlying(Fields::kAudioStreamID), audioStreamID);
    encoder.Encode(to_underlying(Fields::kICEServers), ICEServers);
    encoder.Encode(to_underlying(Fields::kICETransportPolicy), ICETransportPolicy);
    encoder.Encode(to_underlying(Fields::kMetadataOptions), metadataOptions);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kWebRTCSessionID))
        {
            err = DataModel::Decode(reader, webRTCSessionID);
        }
        else if (__context_tag == to_underlying(Fields::kSdp))
        {
            err = DataModel::Decode(reader, sdp);
        }
        else if (__context_tag == to_underlying(Fields::kStreamType))
        {
            err = DataModel::Decode(reader, streamType);
        }
        else if (__context_tag == to_underlying(Fields::kVideoStreamID))
        {
            err = DataModel::Decode(reader, videoStreamID);
        }
        else if (__context_tag == to_underlying(Fields::kAudioStreamID))
        {
            err = DataModel::Decode(reader, audioStreamID);
        }
        else if (__context_tag == to_underlying(Fields::kICEServers))
        {
            err = DataModel::Decode(reader, ICEServers);
        }
        else if (__context_tag == to_underlying(Fields::kICETransportPolicy))
        {
            err = DataModel::Decode(reader, ICETransportPolicy);
        }
        else if (__context_tag == to_underlying(Fields::kMetadataOptions))
        {
            err = DataModel::Decode(reader, metadataOptions);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ProvideOffer.
namespace ProvideOfferResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kWebRTCSessionID), webRTCSessionID);
    encoder.Encode(to_underlying(Fields::kVideoStreamID), videoStreamID);
    encoder.Encode(to_underlying(Fields::kAudioStreamID), audioStreamID);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kWebRTCSessionID))
        {
            err = DataModel::Decode(reader, webRTCSessionID);
        }
        else if (__context_tag == to_underlying(Fields::kVideoStreamID))
        {
            err = DataModel::Decode(reader, videoStreamID);
        }
        else if (__context_tag == to_underlying(Fields::kAudioStreamID))
        {
            err = DataModel::Decode(reader, audioStreamID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ProvideOfferResponse.
namespace ProvideAnswer {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kWebRTCSessionID), webRTCSessionID);
    encoder.Encode(to_underlying(Fields::kSdp), sdp);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kWebRTCSessionID))
        {
            err = DataModel::Decode(reader, webRTCSessionID);
        }
        else if (__context_tag == to_underlying(Fields::kSdp))
        {
            err = DataModel::Decode(reader, sdp);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ProvideAnswer.
namespace ProvideICECandidate {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kWebRTCSessionID), webRTCSessionID);
    encoder.Encode(to_underlying(Fields::kICECandidate), ICECandidate);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kWebRTCSessionID))
        {
            err = DataModel::Decode(reader, webRTCSessionID);
        }
        else if (__context_tag == to_underlying(Fields::kICECandidate))
        {
            err = DataModel::Decode(reader, ICECandidate);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ProvideICECandidate.
namespace EndSession {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kWebRTCSessionID), webRTCSessionID);
    encoder.Encode(to_underlying(Fields::kReason), reason);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kWebRTCSessionID))
        {
            err = DataModel::Decode(reader, webRTCSessionID);
        }
        else if (__context_tag == to_underlying(Fields::kReason))
        {
            err = DataModel::Decode(reader, reason);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace EndSession.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::CurrentSessions::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentSessions);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace WebRTCTransportProvider
namespace WebRTCTransportRequestor {
namespace Structs {} // namespace Structs

namespace Commands {
namespace Offer {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kWebRTCSessionID), webRTCSessionID);
    encoder.Encode(to_underlying(Fields::kSdp), sdp);
    encoder.Encode(to_underlying(Fields::kICEServers), ICEServers);
    encoder.Encode(to_underlying(Fields::kICETransportPolicy), ICETransportPolicy);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kWebRTCSessionID))
        {
            err = DataModel::Decode(reader, webRTCSessionID);
        }
        else if (__context_tag == to_underlying(Fields::kSdp))
        {
            err = DataModel::Decode(reader, sdp);
        }
        else if (__context_tag == to_underlying(Fields::kICEServers))
        {
            err = DataModel::Decode(reader, ICEServers);
        }
        else if (__context_tag == to_underlying(Fields::kICETransportPolicy))
        {
            err = DataModel::Decode(reader, ICETransportPolicy);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace Offer.
namespace Answer {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kWebRTCSessionID), webRTCSessionID);
    encoder.Encode(to_underlying(Fields::kSdp), sdp);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kWebRTCSessionID))
        {
            err = DataModel::Decode(reader, webRTCSessionID);
        }
        else if (__context_tag == to_underlying(Fields::kSdp))
        {
            err = DataModel::Decode(reader, sdp);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace Answer.
namespace ICECandidate {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kWebRTCSessionID), webRTCSessionID);
    encoder.Encode(to_underlying(Fields::kICECandidate), ICECandidate);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kWebRTCSessionID))
        {
            err = DataModel::Decode(reader, webRTCSessionID);
        }
        else if (__context_tag == to_underlying(Fields::kICECandidate))
        {
            err = DataModel::Decode(reader, ICECandidate);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ICECandidate.
namespace End {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kWebRTCSessionID), webRTCSessionID);
    encoder.Encode(to_underlying(Fields::kReason), reason);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kWebRTCSessionID))
        {
            err = DataModel::Decode(reader, webRTCSessionID);
        }
        else if (__context_tag == to_underlying(Fields::kReason))
        {
            err = DataModel::Decode(reader, reason);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace End.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::CurrentSessions::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, currentSessions);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace WebRTCTransportRequestor
namespace Chime {
namespace Structs {

namespace ChimeSoundStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kChimeID), chimeID);
    encoder.Encode(to_underlying(Fields::kName), name);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kChimeID))
        {
            err = DataModel::Decode(reader, chimeID);
        }
        else if (__context_tag == to_underlying(Fields::kName))
        {
            err = DataModel::Decode(reader, name);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace ChimeSoundStruct
} // namespace Structs

namespace Commands {
namespace PlayChimeSound {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace PlayChimeSound.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::InstalledChimeSounds::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, installedChimeSounds);
    case Attributes::ActiveChimeID::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, activeChimeID);
    case Attributes::Enabled::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, enabled);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace Chime
namespace EcosystemInformation {
namespace Structs {

namespace EcosystemDeviceStruct {
CHIP_ERROR Type::EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    return DoEncode(aWriter, aTag, NullOptional);
}

CHIP_ERROR Type::EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const
{
    return DoEncode(aWriter, aTag, MakeOptional(aAccessingFabricIndex));
}

CHIP_ERROR Type::DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const
{
    bool includeSensitive = !aAccessingFabricIndex.HasValue() || (aAccessingFabricIndex.Value() == fabricIndex);

    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };

    if (includeSensitive)
    {
        encoder.Encode(to_underlying(Fields::kDeviceName), deviceName);
    }
    if (includeSensitive)
    {
        encoder.Encode(to_underlying(Fields::kDeviceNameLastEdit), deviceNameLastEdit);
    }
    if (includeSensitive)
    {
        encoder.Encode(to_underlying(Fields::kBridgedEndpoint), bridgedEndpoint);
    }
    if (includeSensitive)
    {
        encoder.Encode(to_underlying(Fields::kOriginalEndpoint), originalEndpoint);
    }
    if (includeSensitive)
    {
        encoder.Encode(to_underlying(Fields::kDeviceTypes), deviceTypes);
    }
    if (includeSensitive)
    {
        encoder.Encode(to_underlying(Fields::kUniqueLocationIDs), uniqueLocationIDs);
    }
    if (includeSensitive)
    {
        encoder.Encode(to_underlying(Fields::kUniqueLocationIDsLastEdit), uniqueLocationIDsLastEdit);
    }
    if (aAccessingFabricIndex.HasValue())
    {
        encoder.Encode(to_underlying(Fields::kFabricIndex), fabricIndex);
    }

    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kDeviceName))
        {
            err = DataModel::Decode(reader, deviceName);
        }
        else if (__context_tag == to_underlying(Fields::kDeviceNameLastEdit))
        {
            err = DataModel::Decode(reader, deviceNameLastEdit);
        }
        else if (__context_tag == to_underlying(Fields::kBridgedEndpoint))
        {
            err = DataModel::Decode(reader, bridgedEndpoint);
        }
        else if (__context_tag == to_underlying(Fields::kOriginalEndpoint))
        {
            err = DataModel::Decode(reader, originalEndpoint);
        }
        else if (__context_tag == to_underlying(Fields::kDeviceTypes))
        {
            err = DataModel::Decode(reader, deviceTypes);
        }
        else if (__context_tag == to_underlying(Fields::kUniqueLocationIDs))
        {
            err = DataModel::Decode(reader, uniqueLocationIDs);
        }
        else if (__context_tag == to_underlying(Fields::kUniqueLocationIDsLastEdit))
        {
            err = DataModel::Decode(reader, uniqueLocationIDsLastEdit);
        }
        else if (__context_tag == to_underlying(Fields::kFabricIndex))
        {
            err = DataModel::Decode(reader, fabricIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace EcosystemDeviceStruct

namespace EcosystemLocationStruct {
CHIP_ERROR Type::EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    return DoEncode(aWriter, aTag, NullOptional);
}

CHIP_ERROR Type::EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const
{
    return DoEncode(aWriter, aTag, MakeOptional(aAccessingFabricIndex));
}

CHIP_ERROR Type::DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const
{
    bool includeSensitive = !aAccessingFabricIndex.HasValue() || (aAccessingFabricIndex.Value() == fabricIndex);

    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };

    if (includeSensitive)
    {
        encoder.Encode(to_underlying(Fields::kUniqueLocationID), uniqueLocationID);
    }
    if (includeSensitive)
    {
        encoder.Encode(to_underlying(Fields::kLocationDescriptor), locationDescriptor);
    }
    if (includeSensitive)
    {
        encoder.Encode(to_underlying(Fields::kLocationDescriptorLastEdit), locationDescriptorLastEdit);
    }
    if (aAccessingFabricIndex.HasValue())
    {
        encoder.Encode(to_underlying(Fields::kFabricIndex), fabricIndex);
    }

    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kUniqueLocationID))
        {
            err = DataModel::Decode(reader, uniqueLocationID);
        }
        else if (__context_tag == to_underlying(Fields::kLocationDescriptor))
        {
            err = DataModel::Decode(reader, locationDescriptor);
        }
        else if (__context_tag == to_underlying(Fields::kLocationDescriptorLastEdit))
        {
            err = DataModel::Decode(reader, locationDescriptorLastEdit);
        }
        else if (__context_tag == to_underlying(Fields::kFabricIndex))
        {
            err = DataModel::Decode(reader, fabricIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace EcosystemLocationStruct
} // namespace Structs

namespace Commands {} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::DeviceDirectory::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, deviceDirectory);
    case Attributes::LocationDirectory::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, locationDirectory);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace EcosystemInformation
namespace CommissionerControl {

namespace Commands {
namespace RequestCommissioningApproval {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kRequestID), requestID);
    encoder.Encode(to_underlying(Fields::kVendorID), vendorID);
    encoder.Encode(to_underlying(Fields::kProductID), productID);
    encoder.Encode(to_underlying(Fields::kLabel), label);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kRequestID))
        {
            err = DataModel::Decode(reader, requestID);
        }
        else if (__context_tag == to_underlying(Fields::kVendorID))
        {
            err = DataModel::Decode(reader, vendorID);
        }
        else if (__context_tag == to_underlying(Fields::kProductID))
        {
            err = DataModel::Decode(reader, productID);
        }
        else if (__context_tag == to_underlying(Fields::kLabel))
        {
            err = DataModel::Decode(reader, label);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace RequestCommissioningApproval.
namespace CommissionNode {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kRequestID), requestID);
    encoder.Encode(to_underlying(Fields::kResponseTimeoutSeconds), responseTimeoutSeconds);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kRequestID))
        {
            err = DataModel::Decode(reader, requestID);
        }
        else if (__context_tag == to_underlying(Fields::kResponseTimeoutSeconds))
        {
            err = DataModel::Decode(reader, responseTimeoutSeconds);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace CommissionNode.
namespace ReverseOpenCommissioningWindow {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kCommissioningTimeout), commissioningTimeout);
    encoder.Encode(to_underlying(Fields::kPAKEPasscodeVerifier), PAKEPasscodeVerifier);
    encoder.Encode(to_underlying(Fields::kDiscriminator), discriminator);
    encoder.Encode(to_underlying(Fields::kIterations), iterations);
    encoder.Encode(to_underlying(Fields::kSalt), salt);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCommissioningTimeout))
        {
            err = DataModel::Decode(reader, commissioningTimeout);
        }
        else if (__context_tag == to_underlying(Fields::kPAKEPasscodeVerifier))
        {
            err = DataModel::Decode(reader, PAKEPasscodeVerifier);
        }
        else if (__context_tag == to_underlying(Fields::kDiscriminator))
        {
            err = DataModel::Decode(reader, discriminator);
        }
        else if (__context_tag == to_underlying(Fields::kIterations))
        {
            err = DataModel::Decode(reader, iterations);
        }
        else if (__context_tag == to_underlying(Fields::kSalt))
        {
            err = DataModel::Decode(reader, salt);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace ReverseOpenCommissioningWindow.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::SupportedDeviceCategories::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, supportedDeviceCategories);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace CommissioningRequestResult {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kRequestID), requestID));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kClientNodeID), clientNodeID));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kStatusCode), statusCode));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kFabricIndex), fabricIndex));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kRequestID))
        {
            err = DataModel::Decode(reader, requestID);
        }
        else if (__context_tag == to_underlying(Fields::kClientNodeID))
        {
            err = DataModel::Decode(reader, clientNodeID);
        }
        else if (__context_tag == to_underlying(Fields::kStatusCode))
        {
            err = DataModel::Decode(reader, statusCode);
        }
        else if (__context_tag == to_underlying(Fields::kFabricIndex))
        {
            err = DataModel::Decode(reader, fabricIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace CommissioningRequestResult.
} // namespace Events

} // namespace CommissionerControl
namespace UnitTesting {
namespace Structs {

namespace SimpleStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kA), a);
    encoder.Encode(to_underlying(Fields::kB), b);
    encoder.Encode(to_underlying(Fields::kC), c);
    encoder.Encode(to_underlying(Fields::kD), d);
    encoder.Encode(to_underlying(Fields::kE), e);
    encoder.Encode(to_underlying(Fields::kF), f);
    encoder.Encode(to_underlying(Fields::kG), g);
    encoder.Encode(to_underlying(Fields::kH), h);
    encoder.Encode(to_underlying(Fields::kI), i);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kA))
        {
            err = DataModel::Decode(reader, a);
        }
        else if (__context_tag == to_underlying(Fields::kB))
        {
            err = DataModel::Decode(reader, b);
        }
        else if (__context_tag == to_underlying(Fields::kC))
        {
            err = DataModel::Decode(reader, c);
        }
        else if (__context_tag == to_underlying(Fields::kD))
        {
            err = DataModel::Decode(reader, d);
        }
        else if (__context_tag == to_underlying(Fields::kE))
        {
            err = DataModel::Decode(reader, e);
        }
        else if (__context_tag == to_underlying(Fields::kF))
        {
            err = DataModel::Decode(reader, f);
        }
        else if (__context_tag == to_underlying(Fields::kG))
        {
            err = DataModel::Decode(reader, g);
        }
        else if (__context_tag == to_underlying(Fields::kH))
        {
            err = DataModel::Decode(reader, h);
        }
        else if (__context_tag == to_underlying(Fields::kI))
        {
            err = DataModel::Decode(reader, i);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace SimpleStruct

namespace TestFabricScoped {
CHIP_ERROR Type::EncodeForWrite(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    return DoEncode(aWriter, aTag, NullOptional);
}

CHIP_ERROR Type::EncodeForRead(TLV::TLVWriter & aWriter, TLV::Tag aTag, FabricIndex aAccessingFabricIndex) const
{
    return DoEncode(aWriter, aTag, MakeOptional(aAccessingFabricIndex));
}

CHIP_ERROR Type::DoEncode(TLV::TLVWriter & aWriter, TLV::Tag aTag, const Optional<FabricIndex> & aAccessingFabricIndex) const
{
    bool includeSensitive = !aAccessingFabricIndex.HasValue() || (aAccessingFabricIndex.Value() == fabricIndex);

    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };

    if (includeSensitive)
    {
        encoder.Encode(to_underlying(Fields::kFabricSensitiveInt8u), fabricSensitiveInt8u);
    }
    if (includeSensitive)
    {
        encoder.Encode(to_underlying(Fields::kOptionalFabricSensitiveInt8u), optionalFabricSensitiveInt8u);
    }
    if (includeSensitive)
    {
        encoder.Encode(to_underlying(Fields::kNullableFabricSensitiveInt8u), nullableFabricSensitiveInt8u);
    }
    if (includeSensitive)
    {
        encoder.Encode(to_underlying(Fields::kNullableOptionalFabricSensitiveInt8u), nullableOptionalFabricSensitiveInt8u);
    }
    if (includeSensitive)
    {
        encoder.Encode(to_underlying(Fields::kFabricSensitiveCharString), fabricSensitiveCharString);
    }
    if (includeSensitive)
    {
        encoder.Encode(to_underlying(Fields::kFabricSensitiveStruct), fabricSensitiveStruct);
    }
    if (includeSensitive)
    {
        encoder.Encode(to_underlying(Fields::kFabricSensitiveInt8uList), fabricSensitiveInt8uList);
    }
    if (aAccessingFabricIndex.HasValue())
    {
        encoder.Encode(to_underlying(Fields::kFabricIndex), fabricIndex);
    }

    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kFabricSensitiveInt8u))
        {
            err = DataModel::Decode(reader, fabricSensitiveInt8u);
        }
        else if (__context_tag == to_underlying(Fields::kOptionalFabricSensitiveInt8u))
        {
            err = DataModel::Decode(reader, optionalFabricSensitiveInt8u);
        }
        else if (__context_tag == to_underlying(Fields::kNullableFabricSensitiveInt8u))
        {
            err = DataModel::Decode(reader, nullableFabricSensitiveInt8u);
        }
        else if (__context_tag == to_underlying(Fields::kNullableOptionalFabricSensitiveInt8u))
        {
            err = DataModel::Decode(reader, nullableOptionalFabricSensitiveInt8u);
        }
        else if (__context_tag == to_underlying(Fields::kFabricSensitiveCharString))
        {
            err = DataModel::Decode(reader, fabricSensitiveCharString);
        }
        else if (__context_tag == to_underlying(Fields::kFabricSensitiveStruct))
        {
            err = DataModel::Decode(reader, fabricSensitiveStruct);
        }
        else if (__context_tag == to_underlying(Fields::kFabricSensitiveInt8uList))
        {
            err = DataModel::Decode(reader, fabricSensitiveInt8uList);
        }
        else if (__context_tag == to_underlying(Fields::kFabricIndex))
        {
            err = DataModel::Decode(reader, fabricIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace TestFabricScoped

namespace NullablesAndOptionalsStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kNullableInt), nullableInt);
    encoder.Encode(to_underlying(Fields::kOptionalInt), optionalInt);
    encoder.Encode(to_underlying(Fields::kNullableOptionalInt), nullableOptionalInt);
    encoder.Encode(to_underlying(Fields::kNullableString), nullableString);
    encoder.Encode(to_underlying(Fields::kOptionalString), optionalString);
    encoder.Encode(to_underlying(Fields::kNullableOptionalString), nullableOptionalString);
    encoder.Encode(to_underlying(Fields::kNullableStruct), nullableStruct);
    encoder.Encode(to_underlying(Fields::kOptionalStruct), optionalStruct);
    encoder.Encode(to_underlying(Fields::kNullableOptionalStruct), nullableOptionalStruct);
    encoder.Encode(to_underlying(Fields::kNullableList), nullableList);
    encoder.Encode(to_underlying(Fields::kOptionalList), optionalList);
    encoder.Encode(to_underlying(Fields::kNullableOptionalList), nullableOptionalList);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNullableInt))
        {
            err = DataModel::Decode(reader, nullableInt);
        }
        else if (__context_tag == to_underlying(Fields::kOptionalInt))
        {
            err = DataModel::Decode(reader, optionalInt);
        }
        else if (__context_tag == to_underlying(Fields::kNullableOptionalInt))
        {
            err = DataModel::Decode(reader, nullableOptionalInt);
        }
        else if (__context_tag == to_underlying(Fields::kNullableString))
        {
            err = DataModel::Decode(reader, nullableString);
        }
        else if (__context_tag == to_underlying(Fields::kOptionalString))
        {
            err = DataModel::Decode(reader, optionalString);
        }
        else if (__context_tag == to_underlying(Fields::kNullableOptionalString))
        {
            err = DataModel::Decode(reader, nullableOptionalString);
        }
        else if (__context_tag == to_underlying(Fields::kNullableStruct))
        {
            err = DataModel::Decode(reader, nullableStruct);
        }
        else if (__context_tag == to_underlying(Fields::kOptionalStruct))
        {
            err = DataModel::Decode(reader, optionalStruct);
        }
        else if (__context_tag == to_underlying(Fields::kNullableOptionalStruct))
        {
            err = DataModel::Decode(reader, nullableOptionalStruct);
        }
        else if (__context_tag == to_underlying(Fields::kNullableList))
        {
            err = DataModel::Decode(reader, nullableList);
        }
        else if (__context_tag == to_underlying(Fields::kOptionalList))
        {
            err = DataModel::Decode(reader, optionalList);
        }
        else if (__context_tag == to_underlying(Fields::kNullableOptionalList))
        {
            err = DataModel::Decode(reader, nullableOptionalList);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace NullablesAndOptionalsStruct

namespace NestedStruct {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kA), a);
    encoder.Encode(to_underlying(Fields::kB), b);
    encoder.Encode(to_underlying(Fields::kC), c);
    encoder.Encode(to_underlying(Fields::kD), d);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kA))
        {
            err = DataModel::Decode(reader, a);
        }
        else if (__context_tag == to_underlying(Fields::kB))
        {
            err = DataModel::Decode(reader, b);
        }
        else if (__context_tag == to_underlying(Fields::kC))
        {
            err = DataModel::Decode(reader, c);
        }
        else if (__context_tag == to_underlying(Fields::kD))
        {
            err = DataModel::Decode(reader, d);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace NestedStruct

namespace NestedStructList {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kA), a);
    encoder.Encode(to_underlying(Fields::kB), b);
    encoder.Encode(to_underlying(Fields::kC), c);
    encoder.Encode(to_underlying(Fields::kD), d);
    encoder.Encode(to_underlying(Fields::kE), e);
    encoder.Encode(to_underlying(Fields::kF), f);
    encoder.Encode(to_underlying(Fields::kG), g);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kA))
        {
            err = DataModel::Decode(reader, a);
        }
        else if (__context_tag == to_underlying(Fields::kB))
        {
            err = DataModel::Decode(reader, b);
        }
        else if (__context_tag == to_underlying(Fields::kC))
        {
            err = DataModel::Decode(reader, c);
        }
        else if (__context_tag == to_underlying(Fields::kD))
        {
            err = DataModel::Decode(reader, d);
        }
        else if (__context_tag == to_underlying(Fields::kE))
        {
            err = DataModel::Decode(reader, e);
        }
        else if (__context_tag == to_underlying(Fields::kF))
        {
            err = DataModel::Decode(reader, f);
        }
        else if (__context_tag == to_underlying(Fields::kG))
        {
            err = DataModel::Decode(reader, g);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace NestedStructList

namespace DoubleNestedStructList {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kA), a);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kA))
        {
            err = DataModel::Decode(reader, a);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace DoubleNestedStructList

namespace TestListStructOctet {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kMember1), member1);
    encoder.Encode(to_underlying(Fields::kMember2), member2);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kMember1))
        {
            err = DataModel::Decode(reader, member1);
        }
        else if (__context_tag == to_underlying(Fields::kMember2))
        {
            err = DataModel::Decode(reader, member2);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}

} // namespace TestListStructOctet
} // namespace Structs

namespace Commands {
namespace Test {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace Test.
namespace TestSpecificResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kReturnValue), returnValue);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kReturnValue))
        {
            err = DataModel::Decode(reader, returnValue);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestSpecificResponse.
namespace TestNotHandled {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace TestNotHandled.
namespace TestAddArgumentsResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kReturnValue), returnValue);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kReturnValue))
        {
            err = DataModel::Decode(reader, returnValue);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestAddArgumentsResponse.
namespace TestSpecific {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace TestSpecific.
namespace TestSimpleArgumentResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kReturnValue), returnValue);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kReturnValue))
        {
            err = DataModel::Decode(reader, returnValue);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestSimpleArgumentResponse.
namespace TestUnknownCommand {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace TestUnknownCommand.
namespace TestStructArrayArgumentResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kArg1), arg1);
    encoder.Encode(to_underlying(Fields::kArg2), arg2);
    encoder.Encode(to_underlying(Fields::kArg3), arg3);
    encoder.Encode(to_underlying(Fields::kArg4), arg4);
    encoder.Encode(to_underlying(Fields::kArg5), arg5);
    encoder.Encode(to_underlying(Fields::kArg6), arg6);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kArg1))
        {
            err = DataModel::Decode(reader, arg1);
        }
        else if (__context_tag == to_underlying(Fields::kArg2))
        {
            err = DataModel::Decode(reader, arg2);
        }
        else if (__context_tag == to_underlying(Fields::kArg3))
        {
            err = DataModel::Decode(reader, arg3);
        }
        else if (__context_tag == to_underlying(Fields::kArg4))
        {
            err = DataModel::Decode(reader, arg4);
        }
        else if (__context_tag == to_underlying(Fields::kArg5))
        {
            err = DataModel::Decode(reader, arg5);
        }
        else if (__context_tag == to_underlying(Fields::kArg6))
        {
            err = DataModel::Decode(reader, arg6);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestStructArrayArgumentResponse.
namespace TestAddArguments {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kArg1), arg1);
    encoder.Encode(to_underlying(Fields::kArg2), arg2);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kArg1))
        {
            err = DataModel::Decode(reader, arg1);
        }
        else if (__context_tag == to_underlying(Fields::kArg2))
        {
            err = DataModel::Decode(reader, arg2);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestAddArguments.
namespace TestListInt8UReverseResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kArg1), arg1);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kArg1))
        {
            err = DataModel::Decode(reader, arg1);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestListInt8UReverseResponse.
namespace TestSimpleArgumentRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kArg1), arg1);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kArg1))
        {
            err = DataModel::Decode(reader, arg1);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestSimpleArgumentRequest.
namespace TestEnumsResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kArg1), arg1);
    encoder.Encode(to_underlying(Fields::kArg2), arg2);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kArg1))
        {
            err = DataModel::Decode(reader, arg1);
        }
        else if (__context_tag == to_underlying(Fields::kArg2))
        {
            err = DataModel::Decode(reader, arg2);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestEnumsResponse.
namespace TestStructArrayArgumentRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kArg1), arg1);
    encoder.Encode(to_underlying(Fields::kArg2), arg2);
    encoder.Encode(to_underlying(Fields::kArg3), arg3);
    encoder.Encode(to_underlying(Fields::kArg4), arg4);
    encoder.Encode(to_underlying(Fields::kArg5), arg5);
    encoder.Encode(to_underlying(Fields::kArg6), arg6);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kArg1))
        {
            err = DataModel::Decode(reader, arg1);
        }
        else if (__context_tag == to_underlying(Fields::kArg2))
        {
            err = DataModel::Decode(reader, arg2);
        }
        else if (__context_tag == to_underlying(Fields::kArg3))
        {
            err = DataModel::Decode(reader, arg3);
        }
        else if (__context_tag == to_underlying(Fields::kArg4))
        {
            err = DataModel::Decode(reader, arg4);
        }
        else if (__context_tag == to_underlying(Fields::kArg5))
        {
            err = DataModel::Decode(reader, arg5);
        }
        else if (__context_tag == to_underlying(Fields::kArg6))
        {
            err = DataModel::Decode(reader, arg6);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestStructArrayArgumentRequest.
namespace TestNullableOptionalResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kWasPresent), wasPresent);
    encoder.Encode(to_underlying(Fields::kWasNull), wasNull);
    encoder.Encode(to_underlying(Fields::kValue), value);
    encoder.Encode(to_underlying(Fields::kOriginalValue), originalValue);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kWasPresent))
        {
            err = DataModel::Decode(reader, wasPresent);
        }
        else if (__context_tag == to_underlying(Fields::kWasNull))
        {
            err = DataModel::Decode(reader, wasNull);
        }
        else if (__context_tag == to_underlying(Fields::kValue))
        {
            err = DataModel::Decode(reader, value);
        }
        else if (__context_tag == to_underlying(Fields::kOriginalValue))
        {
            err = DataModel::Decode(reader, originalValue);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestNullableOptionalResponse.
namespace TestStructArgumentRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kArg1), arg1);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kArg1))
        {
            err = DataModel::Decode(reader, arg1);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestStructArgumentRequest.
namespace TestComplexNullableOptionalResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kNullableIntWasNull), nullableIntWasNull);
    encoder.Encode(to_underlying(Fields::kNullableIntValue), nullableIntValue);
    encoder.Encode(to_underlying(Fields::kOptionalIntWasPresent), optionalIntWasPresent);
    encoder.Encode(to_underlying(Fields::kOptionalIntValue), optionalIntValue);
    encoder.Encode(to_underlying(Fields::kNullableOptionalIntWasPresent), nullableOptionalIntWasPresent);
    encoder.Encode(to_underlying(Fields::kNullableOptionalIntWasNull), nullableOptionalIntWasNull);
    encoder.Encode(to_underlying(Fields::kNullableOptionalIntValue), nullableOptionalIntValue);
    encoder.Encode(to_underlying(Fields::kNullableStringWasNull), nullableStringWasNull);
    encoder.Encode(to_underlying(Fields::kNullableStringValue), nullableStringValue);
    encoder.Encode(to_underlying(Fields::kOptionalStringWasPresent), optionalStringWasPresent);
    encoder.Encode(to_underlying(Fields::kOptionalStringValue), optionalStringValue);
    encoder.Encode(to_underlying(Fields::kNullableOptionalStringWasPresent), nullableOptionalStringWasPresent);
    encoder.Encode(to_underlying(Fields::kNullableOptionalStringWasNull), nullableOptionalStringWasNull);
    encoder.Encode(to_underlying(Fields::kNullableOptionalStringValue), nullableOptionalStringValue);
    encoder.Encode(to_underlying(Fields::kNullableStructWasNull), nullableStructWasNull);
    encoder.Encode(to_underlying(Fields::kNullableStructValue), nullableStructValue);
    encoder.Encode(to_underlying(Fields::kOptionalStructWasPresent), optionalStructWasPresent);
    encoder.Encode(to_underlying(Fields::kOptionalStructValue), optionalStructValue);
    encoder.Encode(to_underlying(Fields::kNullableOptionalStructWasPresent), nullableOptionalStructWasPresent);
    encoder.Encode(to_underlying(Fields::kNullableOptionalStructWasNull), nullableOptionalStructWasNull);
    encoder.Encode(to_underlying(Fields::kNullableOptionalStructValue), nullableOptionalStructValue);
    encoder.Encode(to_underlying(Fields::kNullableListWasNull), nullableListWasNull);
    encoder.Encode(to_underlying(Fields::kNullableListValue), nullableListValue);
    encoder.Encode(to_underlying(Fields::kOptionalListWasPresent), optionalListWasPresent);
    encoder.Encode(to_underlying(Fields::kOptionalListValue), optionalListValue);
    encoder.Encode(to_underlying(Fields::kNullableOptionalListWasPresent), nullableOptionalListWasPresent);
    encoder.Encode(to_underlying(Fields::kNullableOptionalListWasNull), nullableOptionalListWasNull);
    encoder.Encode(to_underlying(Fields::kNullableOptionalListValue), nullableOptionalListValue);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNullableIntWasNull))
        {
            err = DataModel::Decode(reader, nullableIntWasNull);
        }
        else if (__context_tag == to_underlying(Fields::kNullableIntValue))
        {
            err = DataModel::Decode(reader, nullableIntValue);
        }
        else if (__context_tag == to_underlying(Fields::kOptionalIntWasPresent))
        {
            err = DataModel::Decode(reader, optionalIntWasPresent);
        }
        else if (__context_tag == to_underlying(Fields::kOptionalIntValue))
        {
            err = DataModel::Decode(reader, optionalIntValue);
        }
        else if (__context_tag == to_underlying(Fields::kNullableOptionalIntWasPresent))
        {
            err = DataModel::Decode(reader, nullableOptionalIntWasPresent);
        }
        else if (__context_tag == to_underlying(Fields::kNullableOptionalIntWasNull))
        {
            err = DataModel::Decode(reader, nullableOptionalIntWasNull);
        }
        else if (__context_tag == to_underlying(Fields::kNullableOptionalIntValue))
        {
            err = DataModel::Decode(reader, nullableOptionalIntValue);
        }
        else if (__context_tag == to_underlying(Fields::kNullableStringWasNull))
        {
            err = DataModel::Decode(reader, nullableStringWasNull);
        }
        else if (__context_tag == to_underlying(Fields::kNullableStringValue))
        {
            err = DataModel::Decode(reader, nullableStringValue);
        }
        else if (__context_tag == to_underlying(Fields::kOptionalStringWasPresent))
        {
            err = DataModel::Decode(reader, optionalStringWasPresent);
        }
        else if (__context_tag == to_underlying(Fields::kOptionalStringValue))
        {
            err = DataModel::Decode(reader, optionalStringValue);
        }
        else if (__context_tag == to_underlying(Fields::kNullableOptionalStringWasPresent))
        {
            err = DataModel::Decode(reader, nullableOptionalStringWasPresent);
        }
        else if (__context_tag == to_underlying(Fields::kNullableOptionalStringWasNull))
        {
            err = DataModel::Decode(reader, nullableOptionalStringWasNull);
        }
        else if (__context_tag == to_underlying(Fields::kNullableOptionalStringValue))
        {
            err = DataModel::Decode(reader, nullableOptionalStringValue);
        }
        else if (__context_tag == to_underlying(Fields::kNullableStructWasNull))
        {
            err = DataModel::Decode(reader, nullableStructWasNull);
        }
        else if (__context_tag == to_underlying(Fields::kNullableStructValue))
        {
            err = DataModel::Decode(reader, nullableStructValue);
        }
        else if (__context_tag == to_underlying(Fields::kOptionalStructWasPresent))
        {
            err = DataModel::Decode(reader, optionalStructWasPresent);
        }
        else if (__context_tag == to_underlying(Fields::kOptionalStructValue))
        {
            err = DataModel::Decode(reader, optionalStructValue);
        }
        else if (__context_tag == to_underlying(Fields::kNullableOptionalStructWasPresent))
        {
            err = DataModel::Decode(reader, nullableOptionalStructWasPresent);
        }
        else if (__context_tag == to_underlying(Fields::kNullableOptionalStructWasNull))
        {
            err = DataModel::Decode(reader, nullableOptionalStructWasNull);
        }
        else if (__context_tag == to_underlying(Fields::kNullableOptionalStructValue))
        {
            err = DataModel::Decode(reader, nullableOptionalStructValue);
        }
        else if (__context_tag == to_underlying(Fields::kNullableListWasNull))
        {
            err = DataModel::Decode(reader, nullableListWasNull);
        }
        else if (__context_tag == to_underlying(Fields::kNullableListValue))
        {
            err = DataModel::Decode(reader, nullableListValue);
        }
        else if (__context_tag == to_underlying(Fields::kOptionalListWasPresent))
        {
            err = DataModel::Decode(reader, optionalListWasPresent);
        }
        else if (__context_tag == to_underlying(Fields::kOptionalListValue))
        {
            err = DataModel::Decode(reader, optionalListValue);
        }
        else if (__context_tag == to_underlying(Fields::kNullableOptionalListWasPresent))
        {
            err = DataModel::Decode(reader, nullableOptionalListWasPresent);
        }
        else if (__context_tag == to_underlying(Fields::kNullableOptionalListWasNull))
        {
            err = DataModel::Decode(reader, nullableOptionalListWasNull);
        }
        else if (__context_tag == to_underlying(Fields::kNullableOptionalListValue))
        {
            err = DataModel::Decode(reader, nullableOptionalListValue);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestComplexNullableOptionalResponse.
namespace TestNestedStructArgumentRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kArg1), arg1);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kArg1))
        {
            err = DataModel::Decode(reader, arg1);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestNestedStructArgumentRequest.
namespace BooleanResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kValue), value);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kValue))
        {
            err = DataModel::Decode(reader, value);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace BooleanResponse.
namespace TestListStructArgumentRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kArg1), arg1);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kArg1))
        {
            err = DataModel::Decode(reader, arg1);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestListStructArgumentRequest.
namespace SimpleStructResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kArg1), arg1);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kArg1))
        {
            err = DataModel::Decode(reader, arg1);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SimpleStructResponse.
namespace TestListInt8UArgumentRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kArg1), arg1);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kArg1))
        {
            err = DataModel::Decode(reader, arg1);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestListInt8UArgumentRequest.
namespace TestEmitTestEventResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kValue), value);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kValue))
        {
            err = DataModel::Decode(reader, value);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestEmitTestEventResponse.
namespace TestNestedStructListArgumentRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kArg1), arg1);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kArg1))
        {
            err = DataModel::Decode(reader, arg1);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestNestedStructListArgumentRequest.
namespace TestEmitTestFabricScopedEventResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kValue), value);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kValue))
        {
            err = DataModel::Decode(reader, value);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestEmitTestFabricScopedEventResponse.
namespace TestListNestedStructListArgumentRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kArg1), arg1);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kArg1))
        {
            err = DataModel::Decode(reader, arg1);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestListNestedStructListArgumentRequest.
namespace TestBatchHelperResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kBuffer), buffer);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kBuffer))
        {
            err = DataModel::Decode(reader, buffer);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestBatchHelperResponse.
namespace TestListInt8UReverseRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kArg1), arg1);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kArg1))
        {
            err = DataModel::Decode(reader, arg1);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestListInt8UReverseRequest.
namespace StringEchoResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kPayload), payload);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kPayload))
        {
            err = DataModel::Decode(reader, payload);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace StringEchoResponse.
namespace TestEnumsRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kArg1), arg1);
    encoder.Encode(to_underlying(Fields::kArg2), arg2);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kArg1))
        {
            err = DataModel::Decode(reader, arg1);
        }
        else if (__context_tag == to_underlying(Fields::kArg2))
        {
            err = DataModel::Decode(reader, arg2);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestEnumsRequest.
namespace GlobalEchoResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kField1), field1);
    encoder.Encode(to_underlying(Fields::kField2), field2);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kField1))
        {
            err = DataModel::Decode(reader, field1);
        }
        else if (__context_tag == to_underlying(Fields::kField2))
        {
            err = DataModel::Decode(reader, field2);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GlobalEchoResponse.
namespace TestNullableOptionalRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kArg1), arg1);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kArg1))
        {
            err = DataModel::Decode(reader, arg1);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestNullableOptionalRequest.
namespace TestComplexNullableOptionalRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kNullableInt), nullableInt);
    encoder.Encode(to_underlying(Fields::kOptionalInt), optionalInt);
    encoder.Encode(to_underlying(Fields::kNullableOptionalInt), nullableOptionalInt);
    encoder.Encode(to_underlying(Fields::kNullableString), nullableString);
    encoder.Encode(to_underlying(Fields::kOptionalString), optionalString);
    encoder.Encode(to_underlying(Fields::kNullableOptionalString), nullableOptionalString);
    encoder.Encode(to_underlying(Fields::kNullableStruct), nullableStruct);
    encoder.Encode(to_underlying(Fields::kOptionalStruct), optionalStruct);
    encoder.Encode(to_underlying(Fields::kNullableOptionalStruct), nullableOptionalStruct);
    encoder.Encode(to_underlying(Fields::kNullableList), nullableList);
    encoder.Encode(to_underlying(Fields::kOptionalList), optionalList);
    encoder.Encode(to_underlying(Fields::kNullableOptionalList), nullableOptionalList);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kNullableInt))
        {
            err = DataModel::Decode(reader, nullableInt);
        }
        else if (__context_tag == to_underlying(Fields::kOptionalInt))
        {
            err = DataModel::Decode(reader, optionalInt);
        }
        else if (__context_tag == to_underlying(Fields::kNullableOptionalInt))
        {
            err = DataModel::Decode(reader, nullableOptionalInt);
        }
        else if (__context_tag == to_underlying(Fields::kNullableString))
        {
            err = DataModel::Decode(reader, nullableString);
        }
        else if (__context_tag == to_underlying(Fields::kOptionalString))
        {
            err = DataModel::Decode(reader, optionalString);
        }
        else if (__context_tag == to_underlying(Fields::kNullableOptionalString))
        {
            err = DataModel::Decode(reader, nullableOptionalString);
        }
        else if (__context_tag == to_underlying(Fields::kNullableStruct))
        {
            err = DataModel::Decode(reader, nullableStruct);
        }
        else if (__context_tag == to_underlying(Fields::kOptionalStruct))
        {
            err = DataModel::Decode(reader, optionalStruct);
        }
        else if (__context_tag == to_underlying(Fields::kNullableOptionalStruct))
        {
            err = DataModel::Decode(reader, nullableOptionalStruct);
        }
        else if (__context_tag == to_underlying(Fields::kNullableList))
        {
            err = DataModel::Decode(reader, nullableList);
        }
        else if (__context_tag == to_underlying(Fields::kOptionalList))
        {
            err = DataModel::Decode(reader, optionalList);
        }
        else if (__context_tag == to_underlying(Fields::kNullableOptionalList))
        {
            err = DataModel::Decode(reader, nullableOptionalList);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestComplexNullableOptionalRequest.
namespace SimpleStructEchoRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kArg1), arg1);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kArg1))
        {
            err = DataModel::Decode(reader, arg1);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace SimpleStructEchoRequest.
namespace TimedInvokeRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace TimedInvokeRequest.
namespace TestSimpleOptionalArgumentRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kArg1), arg1);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kArg1))
        {
            err = DataModel::Decode(reader, arg1);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestSimpleOptionalArgumentRequest.
namespace TestEmitTestEventRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kArg1), arg1);
    encoder.Encode(to_underlying(Fields::kArg2), arg2);
    encoder.Encode(to_underlying(Fields::kArg3), arg3);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kArg1))
        {
            err = DataModel::Decode(reader, arg1);
        }
        else if (__context_tag == to_underlying(Fields::kArg2))
        {
            err = DataModel::Decode(reader, arg2);
        }
        else if (__context_tag == to_underlying(Fields::kArg3))
        {
            err = DataModel::Decode(reader, arg3);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestEmitTestEventRequest.
namespace TestEmitTestFabricScopedEventRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kArg1), arg1);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kArg1))
        {
            err = DataModel::Decode(reader, arg1);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestEmitTestFabricScopedEventRequest.
namespace TestBatchHelperRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kSleepBeforeResponseTimeMs), sleepBeforeResponseTimeMs);
    encoder.Encode(to_underlying(Fields::kSizeOfResponseBuffer), sizeOfResponseBuffer);
    encoder.Encode(to_underlying(Fields::kFillCharacter), fillCharacter);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kSleepBeforeResponseTimeMs))
        {
            err = DataModel::Decode(reader, sleepBeforeResponseTimeMs);
        }
        else if (__context_tag == to_underlying(Fields::kSizeOfResponseBuffer))
        {
            err = DataModel::Decode(reader, sizeOfResponseBuffer);
        }
        else if (__context_tag == to_underlying(Fields::kFillCharacter))
        {
            err = DataModel::Decode(reader, fillCharacter);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestBatchHelperRequest.
namespace TestSecondBatchHelperRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kSleepBeforeResponseTimeMs), sleepBeforeResponseTimeMs);
    encoder.Encode(to_underlying(Fields::kSizeOfResponseBuffer), sizeOfResponseBuffer);
    encoder.Encode(to_underlying(Fields::kFillCharacter), fillCharacter);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kSleepBeforeResponseTimeMs))
        {
            err = DataModel::Decode(reader, sleepBeforeResponseTimeMs);
        }
        else if (__context_tag == to_underlying(Fields::kSizeOfResponseBuffer))
        {
            err = DataModel::Decode(reader, sizeOfResponseBuffer);
        }
        else if (__context_tag == to_underlying(Fields::kFillCharacter))
        {
            err = DataModel::Decode(reader, fillCharacter);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestSecondBatchHelperRequest.
namespace StringEchoRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kPayload), payload);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kPayload))
        {
            err = DataModel::Decode(reader, payload);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace StringEchoRequest.
namespace GlobalEchoRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kField1), field1);
    encoder.Encode(to_underlying(Fields::kField2), field2);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kField1))
        {
            err = DataModel::Decode(reader, field1);
        }
        else if (__context_tag == to_underlying(Fields::kField2))
        {
            err = DataModel::Decode(reader, field2);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace GlobalEchoRequest.
namespace TestDifferentVendorMeiRequest {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kArg1), arg1);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kArg1))
        {
            err = DataModel::Decode(reader, arg1);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestDifferentVendorMeiRequest.
namespace TestDifferentVendorMeiResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kArg1), arg1);
    encoder.Encode(to_underlying(Fields::kEventNumber), eventNumber);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kArg1))
        {
            err = DataModel::Decode(reader, arg1);
        }
        else if (__context_tag == to_underlying(Fields::kEventNumber))
        {
            err = DataModel::Decode(reader, eventNumber);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestDifferentVendorMeiResponse.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::Boolean::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, boolean);
    case Attributes::Bitmap8::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, bitmap8);
    case Attributes::Bitmap16::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, bitmap16);
    case Attributes::Bitmap32::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, bitmap32);
    case Attributes::Bitmap64::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, bitmap64);
    case Attributes::Int8u::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, int8u);
    case Attributes::Int16u::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, int16u);
    case Attributes::Int24u::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, int24u);
    case Attributes::Int32u::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, int32u);
    case Attributes::Int40u::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, int40u);
    case Attributes::Int48u::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, int48u);
    case Attributes::Int56u::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, int56u);
    case Attributes::Int64u::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, int64u);
    case Attributes::Int8s::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, int8s);
    case Attributes::Int16s::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, int16s);
    case Attributes::Int24s::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, int24s);
    case Attributes::Int32s::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, int32s);
    case Attributes::Int40s::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, int40s);
    case Attributes::Int48s::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, int48s);
    case Attributes::Int56s::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, int56s);
    case Attributes::Int64s::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, int64s);
    case Attributes::Enum8::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, enum8);
    case Attributes::Enum16::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, enum16);
    case Attributes::FloatSingle::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, floatSingle);
    case Attributes::FloatDouble::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, floatDouble);
    case Attributes::OctetString::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, octetString);
    case Attributes::ListInt8u::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, listInt8u);
    case Attributes::ListOctetString::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, listOctetString);
    case Attributes::ListStructOctetString::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, listStructOctetString);
    case Attributes::LongOctetString::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, longOctetString);
    case Attributes::CharString::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, charString);
    case Attributes::LongCharString::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, longCharString);
    case Attributes::EpochUs::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, epochUs);
    case Attributes::EpochS::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, epochS);
    case Attributes::VendorId::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, vendorId);
    case Attributes::ListNullablesAndOptionalsStruct::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, listNullablesAndOptionalsStruct);
    case Attributes::EnumAttr::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, enumAttr);
    case Attributes::StructAttr::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, structAttr);
    case Attributes::RangeRestrictedInt8u::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, rangeRestrictedInt8u);
    case Attributes::RangeRestrictedInt8s::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, rangeRestrictedInt8s);
    case Attributes::RangeRestrictedInt16u::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, rangeRestrictedInt16u);
    case Attributes::RangeRestrictedInt16s::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, rangeRestrictedInt16s);
    case Attributes::ListLongOctetString::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, listLongOctetString);
    case Attributes::ListFabricScoped::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, listFabricScoped);
    case Attributes::TimedWriteBoolean::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, timedWriteBoolean);
    case Attributes::GeneralErrorBoolean::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generalErrorBoolean);
    case Attributes::ClusterErrorBoolean::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterErrorBoolean);
    case Attributes::GlobalEnum::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, globalEnum);
    case Attributes::GlobalStruct::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, globalStruct);
    case Attributes::Unsupported::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, unsupported);
    case Attributes::ReadFailureCode::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, readFailureCode);
    case Attributes::FailureInt32U::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, failureInt32U);
    case Attributes::NullableBoolean::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableBoolean);
    case Attributes::NullableBitmap8::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableBitmap8);
    case Attributes::NullableBitmap16::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableBitmap16);
    case Attributes::NullableBitmap32::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableBitmap32);
    case Attributes::NullableBitmap64::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableBitmap64);
    case Attributes::NullableInt8u::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableInt8u);
    case Attributes::NullableInt16u::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableInt16u);
    case Attributes::NullableInt24u::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableInt24u);
    case Attributes::NullableInt32u::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableInt32u);
    case Attributes::NullableInt40u::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableInt40u);
    case Attributes::NullableInt48u::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableInt48u);
    case Attributes::NullableInt56u::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableInt56u);
    case Attributes::NullableInt64u::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableInt64u);
    case Attributes::NullableInt8s::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableInt8s);
    case Attributes::NullableInt16s::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableInt16s);
    case Attributes::NullableInt24s::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableInt24s);
    case Attributes::NullableInt32s::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableInt32s);
    case Attributes::NullableInt40s::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableInt40s);
    case Attributes::NullableInt48s::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableInt48s);
    case Attributes::NullableInt56s::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableInt56s);
    case Attributes::NullableInt64s::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableInt64s);
    case Attributes::NullableEnum8::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableEnum8);
    case Attributes::NullableEnum16::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableEnum16);
    case Attributes::NullableFloatSingle::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableFloatSingle);
    case Attributes::NullableFloatDouble::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableFloatDouble);
    case Attributes::NullableOctetString::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableOctetString);
    case Attributes::NullableCharString::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableCharString);
    case Attributes::NullableEnumAttr::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableEnumAttr);
    case Attributes::NullableStruct::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableStruct);
    case Attributes::NullableRangeRestrictedInt8u::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableRangeRestrictedInt8u);
    case Attributes::NullableRangeRestrictedInt8s::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableRangeRestrictedInt8s);
    case Attributes::NullableRangeRestrictedInt16u::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableRangeRestrictedInt16u);
    case Attributes::NullableRangeRestrictedInt16s::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableRangeRestrictedInt16s);
    case Attributes::WriteOnlyInt8u::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, writeOnlyInt8u);
    case Attributes::NullableGlobalEnum::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableGlobalEnum);
    case Attributes::NullableGlobalStruct::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, nullableGlobalStruct);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    case Attributes::MeiInt8u::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, meiInt8u);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace TestEvent {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kArg1), arg1));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kArg2), arg2));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kArg3), arg3));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kArg4), arg4));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kArg5), arg5));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kArg6), arg6));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kArg1))
        {
            err = DataModel::Decode(reader, arg1);
        }
        else if (__context_tag == to_underlying(Fields::kArg2))
        {
            err = DataModel::Decode(reader, arg2);
        }
        else if (__context_tag == to_underlying(Fields::kArg3))
        {
            err = DataModel::Decode(reader, arg3);
        }
        else if (__context_tag == to_underlying(Fields::kArg4))
        {
            err = DataModel::Decode(reader, arg4);
        }
        else if (__context_tag == to_underlying(Fields::kArg5))
        {
            err = DataModel::Decode(reader, arg5);
        }
        else if (__context_tag == to_underlying(Fields::kArg6))
        {
            err = DataModel::Decode(reader, arg6);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestEvent.
namespace TestFabricScopedEvent {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kFabricIndex), fabricIndex));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kFabricIndex))
        {
            err = DataModel::Decode(reader, fabricIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestFabricScopedEvent.
namespace TestDifferentVendorMeiEvent {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kArg1), arg1));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kArg1))
        {
            err = DataModel::Decode(reader, arg1);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace TestDifferentVendorMeiEvent.
} // namespace Events

} // namespace UnitTesting
namespace FaultInjection {

namespace Commands {
namespace FailAtFault {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kType), type);
    encoder.Encode(to_underlying(Fields::kId), id);
    encoder.Encode(to_underlying(Fields::kNumCallsToSkip), numCallsToSkip);
    encoder.Encode(to_underlying(Fields::kNumCallsToFail), numCallsToFail);
    encoder.Encode(to_underlying(Fields::kTakeMutex), takeMutex);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kType))
        {
            err = DataModel::Decode(reader, type);
        }
        else if (__context_tag == to_underlying(Fields::kId))
        {
            err = DataModel::Decode(reader, id);
        }
        else if (__context_tag == to_underlying(Fields::kNumCallsToSkip))
        {
            err = DataModel::Decode(reader, numCallsToSkip);
        }
        else if (__context_tag == to_underlying(Fields::kNumCallsToFail))
        {
            err = DataModel::Decode(reader, numCallsToFail);
        }
        else if (__context_tag == to_underlying(Fields::kTakeMutex))
        {
            err = DataModel::Decode(reader, takeMutex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace FailAtFault.
namespace FailRandomlyAtFault {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kType), type);
    encoder.Encode(to_underlying(Fields::kId), id);
    encoder.Encode(to_underlying(Fields::kPercentage), percentage);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kType))
        {
            err = DataModel::Decode(reader, type);
        }
        else if (__context_tag == to_underlying(Fields::kId))
        {
            err = DataModel::Decode(reader, id);
        }
        else if (__context_tag == to_underlying(Fields::kPercentage))
        {
            err = DataModel::Decode(reader, percentage);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace FailRandomlyAtFault.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {} // namespace Events

} // namespace FaultInjection
namespace SampleMei {

namespace Commands {
namespace Ping {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }
    }
}
} // namespace Ping.
namespace AddArgumentsResponse {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kReturnValue), returnValue);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kReturnValue))
        {
            err = DataModel::Decode(reader, returnValue);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace AddArgumentsResponse.
namespace AddArguments {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };
    encoder.Encode(to_underlying(Fields::kArg1), arg1);
    encoder.Encode(to_underlying(Fields::kArg2), arg2);
    return encoder.Finalize();
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kArg1))
        {
            err = DataModel::Decode(reader, arg1);
        }
        else if (__context_tag == to_underlying(Fields::kArg2))
        {
            err = DataModel::Decode(reader, arg2);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace AddArguments.
} // namespace Commands

namespace Attributes {
CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path)
{
    switch (path.mAttributeId)
    {
    case Attributes::FlipFlop::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, flipFlop);
    case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, generatedCommandList);
    case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, acceptedCommandList);
    case Attributes::EventList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, eventList);
    case Attributes::AttributeList::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, attributeList);
    case Attributes::FeatureMap::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, featureMap);
    case Attributes::ClusterRevision::TypeInfo::GetAttributeId():
        return DataModel::Decode(reader, clusterRevision);
    default:
        return CHIP_NO_ERROR;
    }
}
} // namespace Attributes

namespace Events {
namespace PingCountEvent {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCount), count));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kFabricIndex), fabricIndex));
    return aWriter.EndContainer(outer);
}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
{
    detail::StructDecodeIterator __iterator(reader);
    while (true)
    {
        auto __element = __iterator.Next();
        if (std::holds_alternative<CHIP_ERROR>(__element))
        {
            return std::get<CHIP_ERROR>(__element);
        }

        CHIP_ERROR err              = CHIP_NO_ERROR;
        const uint8_t __context_tag = std::get<uint8_t>(__element);

        if (__context_tag == to_underlying(Fields::kCount))
        {
            err = DataModel::Decode(reader, count);
        }
        else if (__context_tag == to_underlying(Fields::kFabricIndex))
        {
            err = DataModel::Decode(reader, fabricIndex);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace PingCountEvent.
} // namespace Events

} // namespace SampleMei

} // namespace Clusters

bool CommandNeedsTimedInvoke(ClusterId aCluster, CommandId aCommand)
{
    // Maybe it would be smaller code to codegen a table and walk over it?
    // Not sure.
    switch (aCluster)
    {
    case Clusters::AdministratorCommissioning::Id: {
        switch (aCommand)
        {
        case Clusters::AdministratorCommissioning::Commands::OpenCommissioningWindow::Id:
        case Clusters::AdministratorCommissioning::Commands::OpenBasicCommissioningWindow::Id:
        case Clusters::AdministratorCommissioning::Commands::RevokeCommissioning::Id:
            return true;
        default:
            return false;
        }
    }
    case Clusters::EnergyEvse::Id: {
        switch (aCommand)
        {
        case Clusters::EnergyEvse::Commands::Disable::Id:
        case Clusters::EnergyEvse::Commands::EnableCharging::Id:
        case Clusters::EnergyEvse::Commands::EnableDischarging::Id:
        case Clusters::EnergyEvse::Commands::StartDiagnostics::Id:
        case Clusters::EnergyEvse::Commands::SetTargets::Id:
        case Clusters::EnergyEvse::Commands::GetTargets::Id:
        case Clusters::EnergyEvse::Commands::ClearTargets::Id:
            return true;
        default:
            return false;
        }
    }
    case Clusters::DoorLock::Id: {
        switch (aCommand)
        {
        case Clusters::DoorLock::Commands::LockDoor::Id:
        case Clusters::DoorLock::Commands::UnlockDoor::Id:
        case Clusters::DoorLock::Commands::UnlockWithTimeout::Id:
        case Clusters::DoorLock::Commands::SetUser::Id:
        case Clusters::DoorLock::Commands::ClearUser::Id:
        case Clusters::DoorLock::Commands::SetCredential::Id:
        case Clusters::DoorLock::Commands::ClearCredential::Id:
        case Clusters::DoorLock::Commands::UnboltDoor::Id:
        case Clusters::DoorLock::Commands::SetAliroReaderConfig::Id:
        case Clusters::DoorLock::Commands::ClearAliroReaderConfig::Id:
            return true;
        default:
            return false;
        }
    }
    case Clusters::ThreadNetworkDirectory::Id: {
        switch (aCommand)
        {
        case Clusters::ThreadNetworkDirectory::Commands::AddNetwork::Id:
        case Clusters::ThreadNetworkDirectory::Commands::RemoveNetwork::Id:
            return true;
        default:
            return false;
        }
    }
    case Clusters::AccountLogin::Id: {
        switch (aCommand)
        {
        case Clusters::AccountLogin::Commands::GetSetupPIN::Id:
        case Clusters::AccountLogin::Commands::Login::Id:
        case Clusters::AccountLogin::Commands::Logout::Id:
            return true;
        default:
            return false;
        }
    }
    case Clusters::UnitTesting::Id: {
        switch (aCommand)
        {
        case Clusters::UnitTesting::Commands::TimedInvokeRequest::Id:
            return true;
        default:
            return false;
        }
    }
    default:
        break;
    }

    return false;
}

bool CommandIsFabricScoped(ClusterId aCluster, CommandId aCommand)
{
    // Maybe it would be smaller code to codegen a table and walk over it?
    // Not sure.
    switch (aCluster)
    {
    case Clusters::Identify::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::Groups::Id: {
        switch (aCommand)
        {
        case Clusters::Groups::Commands::AddGroup::Id:
            return true;
        case Clusters::Groups::Commands::ViewGroup::Id:
            return true;
        case Clusters::Groups::Commands::GetGroupMembership::Id:
            return true;
        case Clusters::Groups::Commands::RemoveGroup::Id:
            return true;
        case Clusters::Groups::Commands::RemoveAllGroups::Id:
            return true;
        case Clusters::Groups::Commands::AddGroupIfIdentifying::Id:
            return true;
        default:
            return false;
        }
    }
    case Clusters::OnOff::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::LevelControl::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::AccessControl::Id: {
        switch (aCommand)
        {
        case Clusters::AccessControl::Commands::ReviewFabricRestrictions::Id:
            return true;
        default:
            return false;
        }
    }
    case Clusters::Actions::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::BasicInformation::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::OtaSoftwareUpdateProvider::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::OtaSoftwareUpdateRequestor::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::GeneralCommissioning::Id: {
        switch (aCommand)
        {
        case Clusters::GeneralCommissioning::Commands::CommissioningComplete::Id:
            return true;
        default:
            return false;
        }
    }
    case Clusters::NetworkCommissioning::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::DiagnosticLogs::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::GeneralDiagnostics::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::SoftwareDiagnostics::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::ThreadNetworkDiagnostics::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::WiFiNetworkDiagnostics::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::EthernetNetworkDiagnostics::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::TimeSynchronization::Id: {
        switch (aCommand)
        {
        case Clusters::TimeSynchronization::Commands::SetTrustedTimeSource::Id:
            return true;
        default:
            return false;
        }
    }
    case Clusters::BridgedDeviceBasicInformation::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::AdministratorCommissioning::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::OperationalCredentials::Id: {
        switch (aCommand)
        {
        case Clusters::OperationalCredentials::Commands::UpdateNOC::Id:
            return true;
        case Clusters::OperationalCredentials::Commands::UpdateFabricLabel::Id:
            return true;
        default:
            return false;
        }
    }
    case Clusters::GroupKeyManagement::Id: {
        switch (aCommand)
        {
        case Clusters::GroupKeyManagement::Commands::KeySetWrite::Id:
            return true;
        case Clusters::GroupKeyManagement::Commands::KeySetRead::Id:
            return true;
        case Clusters::GroupKeyManagement::Commands::KeySetRemove::Id:
            return true;
        case Clusters::GroupKeyManagement::Commands::KeySetReadAllIndices::Id:
            return true;
        default:
            return false;
        }
    }
    case Clusters::IcdManagement::Id: {
        switch (aCommand)
        {
        case Clusters::IcdManagement::Commands::RegisterClient::Id:
            return true;
        case Clusters::IcdManagement::Commands::UnregisterClient::Id:
            return true;
        default:
            return false;
        }
    }
    case Clusters::Timer::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::OvenCavityOperationalState::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::OvenMode::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::ModeSelect::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::LaundryWasherMode::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::RvcRunMode::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::RvcCleanMode::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::TemperatureControl::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::DishwasherMode::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::SmokeCoAlarm::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::DishwasherAlarm::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::MicrowaveOvenControl::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::OperationalState::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::RvcOperationalState::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::ScenesManagement::Id: {
        switch (aCommand)
        {
        case Clusters::ScenesManagement::Commands::AddScene::Id:
            return true;
        case Clusters::ScenesManagement::Commands::ViewScene::Id:
            return true;
        case Clusters::ScenesManagement::Commands::RemoveScene::Id:
            return true;
        case Clusters::ScenesManagement::Commands::RemoveAllScenes::Id:
            return true;
        case Clusters::ScenesManagement::Commands::StoreScene::Id:
            return true;
        case Clusters::ScenesManagement::Commands::RecallScene::Id:
            return true;
        case Clusters::ScenesManagement::Commands::GetSceneMembership::Id:
            return true;
        case Clusters::ScenesManagement::Commands::CopyScene::Id:
            return true;
        default:
            return false;
        }
    }
    case Clusters::HepaFilterMonitoring::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::ActivatedCarbonFilterMonitoring::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::BooleanStateConfiguration::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::ValveConfigurationAndControl::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::WaterHeaterManagement::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::DemandResponseLoadControl::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::Messages::Id: {
        switch (aCommand)
        {
        case Clusters::Messages::Commands::PresentMessagesRequest::Id:
            return true;
        case Clusters::Messages::Commands::CancelMessagesRequest::Id:
            return true;
        default:
            return false;
        }
    }
    case Clusters::DeviceEnergyManagement::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::EnergyEvse::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::EnergyEvseMode::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::WaterHeaterMode::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::DeviceEnergyManagementMode::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::DoorLock::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::WindowCovering::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::ServiceArea::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::Thermostat::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::FanControl::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::ColorControl::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::WiFiNetworkManagement::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::ThreadBorderRouterManagement::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::ThreadNetworkDirectory::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::Channel::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::TargetNavigator::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::MediaPlayback::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::MediaInput::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::LowPower::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::KeypadInput::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::ContentLauncher::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::AudioOutput::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::ApplicationLauncher::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::AccountLogin::Id: {
        switch (aCommand)
        {
        case Clusters::AccountLogin::Commands::GetSetupPIN::Id:
            return true;
        case Clusters::AccountLogin::Commands::Login::Id:
            return true;
        case Clusters::AccountLogin::Commands::Logout::Id:
            return true;
        default:
            return false;
        }
    }
    case Clusters::ContentControl::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::ContentAppObserver::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::ZoneManagement::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::CameraAvStreamManagement::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::WebRTCTransportProvider::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::WebRTCTransportRequestor::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::Chime::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::CommissionerControl::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::UnitTesting::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::FaultInjection::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    case Clusters::SampleMei::Id: {
        switch (aCommand)
        {
        default:
            return false;
        }
    }
    }
    return false;
}

} // namespace app
} // namespace chip