diff --git a/src/app/AttributeCache.cpp b/src/app/AttributeCache.cpp new file mode 100644 index 00000000000000..b027cc0ca8c177 --- /dev/null +++ b/src/app/AttributeCache.cpp @@ -0,0 +1,217 @@ +/* + * + * Copyright (c) 2021 Project CHIP Authors + * All rights reserved. + * + * 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. + */ + +#include "system/SystemPacketBuffer.h" +#include +#include +#include + +namespace chip { +namespace app { + +CHIP_ERROR AttributeCache::UpdateCache(const ConcreteDataAttributePath & aPath, TLV::TLVReader * apData, const StatusIB & aStatus) +{ + AttributeState state; + System::PacketBufferHandle handle; + System::PacketBufferTLVWriter writer; + + if (apData) + { + handle = System::PacketBufferHandle::New(chip::app::kMaxSecureSduLengthBytes); + + writer.Init(std::move(handle), false); + + ReturnErrorOnFailure(writer.CopyElement(TLV::AnonymousTag, *apData)); + ReturnErrorOnFailure(writer.Finalize(&handle)); + + // + // Compact the buffer down to a more reasonably sized packet buffer + // if we can. + // + handle.RightSize(); + + state.Set(std::move(handle)); + } + else + { + state.Set(aStatus); + } + + // + // if the endpoint didn't exist previously, let's track the insertion + // so that we can inform our callback of a new endpoint being added appropriately. + // + if (mCache.find(aPath.mEndpointId) == mCache.end()) + { + mAddedEndpoints.push_back(aPath.mEndpointId); + } + + mCache[aPath.mEndpointId][aPath.mClusterId][aPath.mAttributeId] = std::move(state); + mChangedAttributeSet.insert(aPath); + return CHIP_NO_ERROR; +} + +void AttributeCache::OnReportBegin(const ReadClient * apReadClient) +{ + mChangedAttributeSet.clear(); + mAddedEndpoints.clear(); + mCallback.OnReportBegin(apReadClient); +} + +void AttributeCache::OnReportEnd(const ReadClient * apReadClient) +{ + std::set> changedClusters; + + // + // Add the EndpointId and ClusterId into a set so that we only + // convey unique combinations in the subsequent OnClusterChanged callback. + // + for (auto & path : mChangedAttributeSet) + { + mCallback.OnAttributeChanged(this, path); + changedClusters.insert(std::make_tuple(path.mEndpointId, path.mClusterId)); + } + + for (auto & item : changedClusters) + { + mCallback.OnClusterChanged(this, std::get<0>(item), std::get<1>(item)); + } + + for (auto endpoint : mAddedEndpoints) + { + mCallback.OnEndpointAdded(this, endpoint); + } + + mCallback.OnReportEnd(apReadClient); +} + +void AttributeCache::OnAttributeData(const ReadClient * apReadClient, const ConcreteDataAttributePath & aPath, + TLV::TLVReader * apData, const StatusIB & aStatus) +{ + // + // Since the cache itself is a ReadClient::Callback, it may be incorrectly passed in directly when registering with the + // ReadClient. This should be avoided, since that bypasses the built-in buffered reader adapter callback that is needed for + // lists to work correctly. + // + // Instead, the right callback should be retrieved using GetBufferedCallback(). + // + // To catch such errors, we validate that the provided concrete path never indicates a raw list item operation (which the + // buffered reader will handle and convert for us). + // + // + VerifyOrDie(!aPath.IsListItemOperation()); + + UpdateCache(aPath, apData, aStatus); + + // + // Forward the call through. + // + mCallback.OnAttributeData(apReadClient, aPath, apData, aStatus); +} + +CHIP_ERROR AttributeCache::Get(const ConcreteAttributePath & path, TLV::TLVReader & reader) +{ + CHIP_ERROR err; + + auto attributeState = GetAttributeState(path.mEndpointId, path.mClusterId, path.mAttributeId, err); + ReturnErrorOnFailure(err); + + if (attributeState->Is()) + { + return CHIP_ERROR_IM_STATUS_CODE_RECEIVED; + } + + System::PacketBufferTLVReader bufReader; + + bufReader.Init(attributeState->Get().Retain()); + ReturnErrorOnFailure(bufReader.Next()); + + reader.Init(bufReader); + return CHIP_NO_ERROR; +} + +AttributeCache::EndpointState * AttributeCache::GetEndpointState(EndpointId endpointId, CHIP_ERROR & err) +{ + auto endpointIter = mCache.find(endpointId); + if (endpointIter == mCache.end()) + { + err = CHIP_ERROR_KEY_NOT_FOUND; + return nullptr; + } + + err = CHIP_NO_ERROR; + return &endpointIter->second; +} + +AttributeCache::ClusterState * AttributeCache::GetClusterState(EndpointId endpointId, ClusterId clusterId, CHIP_ERROR & err) +{ + auto endpointState = GetEndpointState(endpointId, err); + if (err != CHIP_NO_ERROR) + { + return nullptr; + } + + auto clusterState = endpointState->find(clusterId); + if (clusterState == endpointState->end()) + { + err = CHIP_ERROR_KEY_NOT_FOUND; + return nullptr; + } + + err = CHIP_NO_ERROR; + return &clusterState->second; +} + +AttributeCache::AttributeState * AttributeCache::GetAttributeState(EndpointId endpointId, ClusterId clusterId, + AttributeId attributeId, CHIP_ERROR & err) +{ + auto clusterState = GetClusterState(endpointId, clusterId, err); + if (err != CHIP_NO_ERROR) + { + return nullptr; + } + + auto attributeState = clusterState->find(attributeId); + if (attributeState == clusterState->end()) + { + err = CHIP_ERROR_KEY_NOT_FOUND; + return nullptr; + } + + err = CHIP_NO_ERROR; + return &attributeState->second; +} + +CHIP_ERROR AttributeCache::GetStatus(const ConcreteAttributePath & path, StatusIB & status) +{ + CHIP_ERROR err; + + auto attributeState = GetAttributeState(path.mEndpointId, path.mClusterId, path.mAttributeId, err); + ReturnErrorOnFailure(err); + + if (!attributeState->Is()) + { + return CHIP_ERROR_INVALID_ARGUMENT; + } + + status = attributeState->Get(); + return CHIP_NO_ERROR; +} + +} // namespace app +} // namespace chip diff --git a/src/app/AttributeCache.h b/src/app/AttributeCache.h new file mode 100644 index 00000000000000..3abb288582a2b8 --- /dev/null +++ b/src/app/AttributeCache.h @@ -0,0 +1,365 @@ +/* + * + * Copyright (c) 2021 Project CHIP Authors + * All rights reserved. + * + * 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. + */ + +#pragma once + +#include "lib/core/CHIPError.h" +#include "system/SystemPacketBuffer.h" +#include "system/TLVPacketBufferBackingStore.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace chip { +namespace app { + +/* + * This implements an attribute cache designed to aggregate attribute data received by a client + * from either read or subscribe interactions and keep it resident and available for clients to + * query at any time while the cache is active. + * + * The cache can be used with either read/subscribe, with the consumer connecting it up appropriately + * to the right ReadClient instance. + * + * The cache provides an up-to-date and consistent view of the state of a target node, with the scope of the + * state being determined by the associated ReadClient's path set. + * + * The cache provides a number of getters and helper functions to iterate over the topology + * of the received data which is organized by endpoint, cluster and attribute ID. These permit greater + * flexibility when dealing with interactions that use wildcards heavily. + * + * The data is stored internally in the cache as TLV. This permits re-use of the existing cluster objects + * to de-serialize the state on-demand. + * + * The cache serves as a callback adapter as well in that it 'forwards' the ReadClient::Callback calls transparently + * through to a registered callback. In addition, it provides its own enhancements to the base ReadClient::Callback + * to make it easier to know what has changed in the cache. + * + * **NOTE** This already includes the BufferedReadCallback, so there is no need to add that to the ReadClient callback chain. + * + */ +class AttributeCache : protected ReadClient::Callback +{ +public: + class Callback : public ReadClient::Callback + { + public: + /* + * Called anytime an attribute value has changed in the cache + */ + virtual void OnAttributeChanged(AttributeCache * cache, const ConcreteAttributePath & path){}; + + /* + * Called anytime any attribute in a cluster has changed in the cache + */ + virtual void OnClusterChanged(AttributeCache * cache, EndpointId endpointId, ClusterId clusterId){}; + + /* + * Called anytime an endpoint was added to the cache + */ + virtual void OnEndpointAdded(AttributeCache * cache, EndpointId endpointId){}; + }; + + AttributeCache(Callback & callback) : mCallback(callback), mBufferedReader(*this) {} + + /* + * When registering as a callback to the ReadClient, the AttributeCache cannot not be passed as a callback + * directly. Instead, utilize this method below to correctly set up the callback chain such that + * the buffered reader is the first callback in the chain before calling into cache subsequently. + */ + ReadClient::Callback & GetBufferedCallback() { return mBufferedReader; } + + /* + * Retrieve the value of an attribute from the cache (if present) given a concrete path and decode + * is using DataModel::Decode into the in-out argument 'value'. + * + * For some types of attributes, the value for the attribute is directly backed by the underlying TLV buffer + * and has pointers into that buffer. (e.g octet strings, char strings and lists). This buffer only remains + * valid until the cached value for that path is updated, so it must not be held + * across any async call boundaries. + * + * The template parameter AttributeObjectTypeT is generally expected to be a + * ClusterName::Attributes::AttributeName::DecodableType, but any + * object that can be decoded using the DataModel::Decode machinery will work. + * + * Notable return values: + * - If the provided attribute object's Cluster and Attribute IDs don't match that of the provided path, + * a CHIP_ERROR_SCHEMA_MISMATCH shall be returned. + * + * - If neither data or status for the specified path don't exist in the cache, CHIP_ERROR_KEY_NOT_FOUND + * shall be returned. + * + * - If a StatusIB is present in the cache instead of data, a CHIP_ERROR_IM_STATUS_CODE_RECEIVED error + * shall be returned from this call instead. The actual StatusIB can be retrieved using the GetStatus() API below. + * + */ + template + CHIP_ERROR Get(const ConcreteAttributePath & path, typename AttributeObjectTypeT::DecodableType & value) + { + TLV::TLVReader reader; + + if (path.mClusterId != AttributeObjectTypeT::GetClusterId() || path.mAttributeId != AttributeObjectTypeT::GetAttributeId()) + { + return CHIP_ERROR_SCHEMA_MISMATCH; + } + + ReturnErrorOnFailure(Get(path, reader)); + return DataModel::Decode(reader, value); + } + + /* + * Retrieve the StatusIB for a given attribute if one exists currently in the cache. + * + * Notable return values: + * - If neither data or status for the specified path don't exist in the cache, CHIP_ERROR_KEY_NOT_FOUND + * shall be returned. + * + * - If data exists in the cache instead of status, CHIP_ERROR_INVALID_ARGUMENT shall be returned. + * + */ + CHIP_ERROR GetStatus(const ConcreteAttributePath & path, StatusIB & status); + + /* + * Encapsulates a StatusIB and a ConcreteAttributePath pair. + */ + struct AttributeStatus + { + AttributeStatus(const ConcreteAttributePath & path, StatusIB & status) : mPath(path), mStatus(status) {} + ConcreteAttributePath mPath; + StatusIB mStatus; + }; + + /* + * Retrieve the value of an entire cluster instance from the cache (if present) given a path + * and decode it using DataModel::Decode into the in-out argument 'value'. If any StatusIBs + * are present in the cache instead of data, they will be provided in the statusList argument. + * + * For some types of attributes, the value for the attribute is directly backed by the underlying TLV buffer + * and has pointers into that buffer. (e.g octet strings, char strings and lists). This buffer only remains + * valid until the cached value for that path is updated, so it must not be held + * across any async call boundaries. + * + * The template parameter ClusterObjectT is generally expected to be a + * ClusterName::Attributes::DecodableType, but any + * object that can be decoded using the DataModel::Decode machinery will work. + * + * Notable return values: + * - If neither data or status for the specified path exist in the cache, CHIP_ERROR_KEY_NOT_FOUND + * shall be returned. + * + */ + template + CHIP_ERROR Get(EndpointId endpointId, ClusterId clusterId, ClusterObjectTypeT & value, std::list & statusList) + { + statusList.clear(); + + return ForEachAttribute(endpointId, clusterId, [&value, this, &statusList](const ConcreteAttributePath & path) { + TLV::TLVReader reader; + CHIP_ERROR err; + + err = Get(path, reader); + if (err == CHIP_ERROR_IM_STATUS_CODE_RECEIVED) + { + StatusIB status; + ReturnErrorOnFailure(GetStatus(path, status)); + statusList.push_back(AttributeStatus(path, status)); + err = CHIP_NO_ERROR; + } + else if (err == CHIP_NO_ERROR) + { + ReturnErrorOnFailure(DataModel::Decode(reader, path, value)); + } + else + { + return err; + } + + return CHIP_NO_ERROR; + }); + } + + /* + * Retrieve the value of an attribute by updating a in-out TLVReader to be positioned + * right at the attribute value. + * + * The underlying TLV buffer only remains valid until the cached value for that path is updated, so it must + * not be held across any async call boundaries. + * + * Notable return values: + * - If neither data nor status for the specified path exist in the cache, CHIP_ERROR_KEY_NOT_FOUND + * shall be returned. + * + * - If a StatusIB is present in the cache instead of data, a CHIP_ERROR_IM_STATUS_CODE_RECEIVED error + * shall be returned from this call instead. The actual StatusIB can be retrieved using the GetStatus() API above. + * + */ + CHIP_ERROR Get(const ConcreteAttributePath & path, TLV::TLVReader & reader); + + /* + * Execute an iterator function that is called for every attribute + * in a given endpoint and cluster. The function when invoked is provided a concrete attribute path + * to every attribute that matches in the cache. + * + * The iterator is expected to have this signature: + * CHIP_ERROR IteratorFunc(const ConcreteAttributePath &path); + * + * Notable return values: + * - If a cluster instance corresponding to endpointId and clusterId doesn't exist in the cache, + * CHIP_ERROR_KEY_NOT_FOUND shall be returned. + * + * - If func returns an error, that will result in termination of any further iteration over attributes + * and that error shall be returned back up to the original call to this function. + * + */ + template + CHIP_ERROR ForEachAttribute(EndpointId endpointId, ClusterId clusterId, IteratorFunc func) + { + CHIP_ERROR err; + + auto clusterState = GetClusterState(endpointId, clusterId, err); + ReturnErrorOnFailure(err); + + for (auto & attributeIter : *clusterState) + { + const ConcreteAttributePath path(endpointId, clusterId, attributeIter.first); + ReturnErrorOnFailure(func(path)); + } + + return CHIP_NO_ERROR; + } + + /* + * Execute an iterator function that is called for every attribute + * for a given cluster across all endpoints in the cache. The function is passed a + * concrete attribute path to every attribute that matches in the cache. + * + * The iterator is expected to have this signature: + * CHIP_ERROR IteratorFunc(const ConcreteAttributePath &path); + * + * Notable return values: + * - If func returns an error, that will result in termination of any further iteration over attributes + * and that error shall be returned back up to the original call to this function. + * + */ + template + CHIP_ERROR ForEachAttribute(ClusterId clusterId, IteratorFunc func) + { + for (auto & endpointIter : mCache) + { + for (auto & clusterIter : endpointIter.second) + { + if (clusterIter.first == clusterId) + { + for (auto & attributeIter : clusterIter.second) + { + const ConcreteAttributePath path(endpointIter.first, clusterId, attributeIter.first); + ReturnErrorOnFailure(func(path)); + } + } + } + } + } + + /* + * Execute an iterator function that is called for every cluster + * in a given endpoint and passed a ClusterId for every cluster that + * matches. + * + * The iterator is expected to have this signature: + * CHIP_ERROR IteratorFunc(ClusterId clusterId); + * + * Notable return values: + * - If func returns an error, that will result in termination of any further iteration over attributes + * and that error shall be returned back up to the original call to this function. + * + */ + template + CHIP_ERROR ForEachCluster(EndpointId endpointId, IteratorFunc func) + { + auto endpointIter = mCache.find(endpointId); + if (endpointIter->first == endpointId) + { + for (auto & clusterIter : endpointIter->second) + { + ReturnErrorOnFailure(func(clusterIter.first)); + } + } + } + +private: + using AttributeState = Variant; + using ClusterState = std::map; + using EndpointState = std::map; + using NodeState = std::map; + + /* + * These functions provide a way to index into the cached state with different sub-sets of a path, returning + * appropriate slices of the data as requested. + * + * In all variants, the respective slice is returned if a valid path is provided. 'err' is updated to reflect + * the status of the operation. + * + * Notable status values: + * - If a cluster instance corresponding to endpointId and clusterId doesn't exist in the cache, + * CHIP_ERROR_KEY_NOT_FOUND shall be returned. + * + */ + EndpointState * GetEndpointState(EndpointId endpointId, CHIP_ERROR & err); + ClusterState * GetClusterState(EndpointId endpointId, ClusterId clusterId, CHIP_ERROR & err); + AttributeState * GetAttributeState(EndpointId endpointId, ClusterId clusterId, AttributeId attributeId, CHIP_ERROR & err); + + /* + * Updates the state of an attribute in the cache given a reader. If the reader is null, the state is updated + * with the provided status. + */ + CHIP_ERROR UpdateCache(const ConcreteDataAttributePath & aPath, TLV::TLVReader * apData, const StatusIB & aStatus); + +private: + // + // ReadClient::Callback + // + void OnReportBegin(const ReadClient * apReadClient) override; + void OnReportEnd(const ReadClient * apReadClient) override; + void OnAttributeData(const ReadClient * apReadClient, const ConcreteDataAttributePath & aPath, TLV::TLVReader * apData, + const StatusIB & aStatus) override; + void OnError(const ReadClient * apReadClient, CHIP_ERROR aError) override { return mCallback.OnError(apReadClient, aError); } + void OnEventData(const ReadClient * apReadClient, const EventHeader & aEventHeader, TLV::TLVReader * apData, + const StatusIB * apStatus) override + { + return mCallback.OnEventData(apReadClient, aEventHeader, apData, apStatus); + } + + void OnDone(ReadClient * apReadClient) override { return mCallback.OnDone(apReadClient); } + void OnSubscriptionEstablished(const ReadClient * apReadClient) override { mCallback.OnSubscriptionEstablished(apReadClient); } + +private: + Callback & mCallback; + NodeState mCache; + std::set mChangedAttributeSet; + std::vector mAddedEndpoints; + BufferedReadCallback mBufferedReader; +}; + +}; // namespace app +}; // namespace chip diff --git a/src/app/BUILD.gn b/src/app/BUILD.gn index f159ae54470ce4..15e996c2d140a6 100644 --- a/src/app/BUILD.gn +++ b/src/app/BUILD.gn @@ -36,6 +36,8 @@ static_library("app") { sources = [ "AttributeAccessInterface.cpp", + "AttributeCache.cpp", + "AttributeCache.h", "AttributePathExpandIterator.cpp", "AttributePathExpandIterator.h", "AttributePathParams.h", diff --git a/src/app/ConcreteAttributePath.h b/src/app/ConcreteAttributePath.h index d1f46914fe7491..0fb764e057fae9 100644 --- a/src/app/ConcreteAttributePath.h +++ b/src/app/ConcreteAttributePath.h @@ -40,7 +40,13 @@ struct ConcreteAttributePath bool operator==(const ConcreteAttributePath & other) const { - return mEndpointId == other.mEndpointId && mClusterId == other.mClusterId && mAttributeId == other.mAttributeId; + return (mEndpointId == other.mEndpointId) && (mClusterId == other.mClusterId) && (mAttributeId == other.mAttributeId); + } + + bool operator<(const ConcreteAttributePath & path) const + { + return (mEndpointId < path.mEndpointId) || ((mEndpointId == path.mEndpointId) && (mClusterId < path.mClusterId)) || + ((mClusterId == path.mClusterId) && (mAttributeId < path.mAttributeId)); } EndpointId mEndpointId = 0; diff --git a/src/app/clusters/test-cluster-server/test-cluster-server.cpp b/src/app/clusters/test-cluster-server/test-cluster-server.cpp index 3477012589b379..ee91dbdebabd5b 100644 --- a/src/app/clusters/test-cluster-server/test-cluster-server.cpp +++ b/src/app/clusters/test-cluster-server/test-cluster-server.cpp @@ -112,7 +112,7 @@ CHIP_ERROR TestAttrAccess::Read(const ConcreteReadAttributePath & aPath, Attribu case ListNullablesAndOptionalsStruct::Id: { return ReadListNullablesAndOptionalsStructAttribute(aEncoder); } - case Struct::Id: { + case StructAttr::Id: { return ReadStructAttribute(aEncoder); } case ListLongOctetString::Id: { @@ -145,7 +145,7 @@ CHIP_ERROR TestAttrAccess::Write(const ConcreteDataAttributePath & aPath, Attrib case ListNullablesAndOptionalsStruct::Id: { return WriteListNullablesAndOptionalsStructAttribute(aDecoder); } - case Struct::Id: { + case StructAttr::Id: { return WriteStructAttribute(aDecoder); } case NullableStruct::Id: { diff --git a/src/app/data-model/Decode.h b/src/app/data-model/Decode.h index f530dd31c1cd9f..dffad80af0e204 100644 --- a/src/app/data-model/Decode.h +++ b/src/app/data-model/Decode.h @@ -18,6 +18,7 @@ #pragma once +#include #include #include #include @@ -102,6 +103,33 @@ CHIP_ERROR Decode(TLV::TLVReader & reader, X & x) return x.Decode(reader); } +/* + * @brief + * + * This specific variant decodes from TLV a cluster object that contains all attributes encapsulated within a single, monolithic + * cluster object. + * + * Each attribute in the cluster is decoded based on the provided ConcreteAttributePath. The TLVReader is to be positioned right on + * the data value for the specified attribute. + * + * This API depends on the presence of a Decode method on the object. The signature of that method + * is as follows: + * + * CHIP_ERROR ::Decode(TLVReader &reader, ConcreteAttributePath &path); + * + */ +template < + typename X, + typename std::enable_if_t::value && + std::is_same().Decode(std::declval(), + std::declval())), + CHIP_ERROR>::value, + X> * = nullptr> +CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path, X & x) +{ + return x.Decode(reader, path); +} + /* * @brief * diff --git a/src/app/tests/BUILD.gn b/src/app/tests/BUILD.gn index 6ee7a6e30f91ae..9f7f4281d5c365 100644 --- a/src/app/tests/BUILD.gn +++ b/src/app/tests/BUILD.gn @@ -67,6 +67,7 @@ chip_test_suite("tests") { # if (chip_device_platform != "nrfconnect") { test_sources += [ "TestBufferedReadCallback.cpp" ] + test_sources += [ "TestAttributeCache.cpp" ] } cflags = [ "-Wconversion" ] diff --git a/src/app/tests/TestAttributeCache.cpp b/src/app/tests/TestAttributeCache.cpp new file mode 100644 index 00000000000000..09dfe133d40635 --- /dev/null +++ b/src/app/tests/TestAttributeCache.cpp @@ -0,0 +1,558 @@ +/* + * + * Copyright (c) 2021 Project CHIP Authors + * All rights reserved. + * + * 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. + */ + +#include "app-common/zap-generated/ids/Attributes.h" +#include "app-common/zap-generated/ids/Clusters.h" +#include "lib/core/CHIPTLVTags.h" +#include "protocols/interaction_model/Constants.h" +#include "system/SystemPacketBuffer.h" +#include "system/TLVPacketBufferBackingStore.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using TestContext = chip::Test::AppContext; +using namespace chip::app; +using namespace chip; + +namespace { + +nlTestSuite * gSuite = nullptr; + +struct AttributeInstruction +{ + enum AttributeType + { + kAttributeA = 0, // int + kAttributeB = 1, // byte string + kAttributeC = 2, // struct + kAttributeD = 3, // list + }; + + enum ValueType + { + kData = 0, + kStatus = 1 + }; + + AttributeType mAttributeType; + EndpointId mEndpointId; + ValueType mValueType; + uint8_t mInstructionId; + + AttributeInstruction() { mInstructionId = sInstructionId++; } + + bool operator<(const AttributeInstruction & instruction) const + { + return (mAttributeType < instruction.mAttributeType || + (!(mAttributeType < instruction.mAttributeType) && (mEndpointId < instruction.mEndpointId))); + } + + AttributeInstruction(AttributeType attributeType, EndpointId endpointId, ValueType valueType) : AttributeInstruction() + { + mAttributeType = attributeType; + mEndpointId = endpointId; + mValueType = valueType; + } + + AttributeId GetAttributeId() const + { + switch (mAttributeType) + { + case kAttributeA: + return Clusters::TestCluster::Attributes::Int16u::Id; + break; + + case kAttributeB: + return Clusters::TestCluster::Attributes::OctetString::Id; + break; + + case kAttributeC: + return Clusters::TestCluster::Attributes::StructAttr::Id; + break; + + default: + return Clusters::TestCluster::Attributes::ListStructOctetString::Id; + break; + } + } + + static uint8_t sInstructionId; +}; + +uint8_t AttributeInstruction::sInstructionId = 0; + +using AttributeInstructionListType = std::vector; + +class DataSeriesGenerator +{ +public: + DataSeriesGenerator(ReadClient::Callback * readCallback, AttributeInstructionListType & instructionList) : + mReadCallback(readCallback), mInstructionList(instructionList) + {} + + void Generate(); + +private: + ReadClient::Callback * mReadCallback; + AttributeInstructionListType & mInstructionList; +}; + +void DataSeriesGenerator::Generate() +{ + System::PacketBufferHandle handle; + System::PacketBufferTLVWriter writer; + System::PacketBufferTLVReader reader; + ReadClient::Callback * callback = mReadCallback; + StatusIB status; + + callback->OnReportBegin(nullptr); + + uint8_t index = 0; + for (auto & instruction : mInstructionList) + { + ConcreteDataAttributePath path(instruction.mEndpointId, Clusters::TestCluster::Id, 0); + handle = System::PacketBufferHandle::New(1000); + writer.Init(std::move(handle), true); + status = StatusIB(); + path.mAttributeId = instruction.GetAttributeId(); + + ChipLogProgress(DataManagement, "\t -- Generating Instruction ID %d", instruction.mInstructionId); + + if (instruction.mValueType == AttributeInstruction::kData) + { + switch (instruction.mAttributeType) + { + case AttributeInstruction::kAttributeA: { + ChipLogProgress(DataManagement, "\t -- Generating A"); + + Clusters::TestCluster::Attributes::Int16u::TypeInfo::Type value = instruction.mInstructionId; + NL_TEST_ASSERT(gSuite, DataModel::Encode(writer, TLV::AnonymousTag, value) == CHIP_NO_ERROR); + break; + } + + case AttributeInstruction::kAttributeB: { + ChipLogProgress(DataManagement, "\t -- Generating B"); + + Clusters::TestCluster::Attributes::OctetString::TypeInfo::Type value; + uint8_t buf[] = { 'h', 'e', 'l', 'l', 'o' }; + value = buf; + + NL_TEST_ASSERT(gSuite, DataModel::Encode(writer, TLV::AnonymousTag, value) == CHIP_NO_ERROR); + break; + } + + case AttributeInstruction::kAttributeC: { + ChipLogProgress(DataManagement, "\t -- Generating C"); + + Clusters::TestCluster::Attributes::StructAttr::TypeInfo::Type value; + value.a = instruction.mInstructionId; + value.b = true; + NL_TEST_ASSERT(gSuite, DataModel::Encode(writer, TLV::AnonymousTag, value) == CHIP_NO_ERROR); + break; + } + + case AttributeInstruction::kAttributeD: { + ChipLogProgress(DataManagement, "\t -- Generating D"); + + Clusters::TestCluster::Structs::TestListStructOctet::Type buf[4]; + + for (auto & i : buf) + { + i.fabricIndex = instruction.mInstructionId; + } + + Clusters::TestCluster::Attributes::ListStructOctetString::TypeInfo::Type value; + path.mListOp = ConcreteDataAttributePath::ListOperation::ReplaceAll; + + value = buf; + NL_TEST_ASSERT(gSuite, DataModel::Encode(writer, TLV::AnonymousTag, value) == CHIP_NO_ERROR); + break; + } + + default: + break; + } + + writer.Finalize(&handle); + reader.Init(std::move(handle)); + NL_TEST_ASSERT(gSuite, reader.Next() == CHIP_NO_ERROR); + callback->OnAttributeData(nullptr, path, &reader, status); + } + else + { + ChipLogProgress(DataManagement, "\t -- Generating Status"); + status.mStatus = Protocols::InteractionModel::Status::Failure; + callback->OnAttributeData(nullptr, path, nullptr, status); + } + + index++; + } + + callback->OnReportEnd(nullptr); +} + +class CacheValidator : public AttributeCache::Callback +{ +public: + CacheValidator(AttributeInstructionListType & instructionList); + + Clusters::TestCluster::Attributes::TypeInfo::DecodableType clusterValue; + +private: + void OnDone(ReadClient * apReadClient) override {} + void DecodeAttribute(const AttributeInstruction & instruction, const ConcreteAttributePath & path, AttributeCache * cache) + { + CHIP_ERROR err; + bool gotStatus = false; + + ChipLogProgress(DataManagement, "\t\t -- Validating Instruction ID: %d", instruction.mInstructionId); + + switch (instruction.mAttributeType) + { + case AttributeInstruction::kAttributeA: { + ChipLogProgress(DataManagement, "\t\t -- Validating A"); + + Clusters::TestCluster::Attributes::Int16u::TypeInfo::DecodableType v; + err = cache->Get(path, v); + if (err == CHIP_ERROR_IM_STATUS_CODE_RECEIVED) + { + gotStatus = true; + err = CHIP_NO_ERROR; + } + else + { + NL_TEST_ASSERT(gSuite, err == CHIP_NO_ERROR); + NL_TEST_ASSERT(gSuite, v == instruction.mInstructionId); + } + + break; + } + + case AttributeInstruction::kAttributeB: { + ChipLogProgress(DataManagement, "\t\t -- Validating B"); + + Clusters::TestCluster::Attributes::OctetString::TypeInfo::DecodableType v; + err = cache->Get(path, v); + if (err == CHIP_ERROR_IM_STATUS_CODE_RECEIVED) + { + gotStatus = true; + err = CHIP_NO_ERROR; + } + else + { + NL_TEST_ASSERT(gSuite, err == CHIP_NO_ERROR); + NL_TEST_ASSERT(gSuite, strncmp((char *) v.data(), "hello", v.size()) == 0); + } + + break; + } + + case AttributeInstruction::kAttributeC: { + ChipLogProgress(DataManagement, "\t\t -- Validating C"); + + Clusters::TestCluster::Attributes::StructAttr::TypeInfo::DecodableType v; + err = cache->Get(path, v); + if (err == CHIP_ERROR_IM_STATUS_CODE_RECEIVED) + { + gotStatus = true; + err = CHIP_NO_ERROR; + } + else + { + NL_TEST_ASSERT(gSuite, v.a == instruction.mInstructionId); + NL_TEST_ASSERT(gSuite, v.b == true); + } + + break; + } + + case AttributeInstruction::kAttributeD: { + ChipLogProgress(DataManagement, "\t\t -- Validating D"); + + Clusters::TestCluster::Attributes::ListStructOctetString::TypeInfo::DecodableType v; + err = cache->Get(path, v); + if (err == CHIP_ERROR_IM_STATUS_CODE_RECEIVED) + { + gotStatus = true; + err = CHIP_NO_ERROR; + } + else + { + auto listIter = v.begin(); + while (listIter.Next()) + { + NL_TEST_ASSERT(gSuite, listIter.GetValue().fabricIndex == instruction.mInstructionId); + } + + NL_TEST_ASSERT(gSuite, listIter.GetStatus() == CHIP_NO_ERROR); + } + + break; + } + } + + NL_TEST_ASSERT(gSuite, err == CHIP_NO_ERROR); + + if (gotStatus) + { + ChipLogProgress(DataManagement, "\t\t -- Validating status"); + NL_TEST_ASSERT(gSuite, instruction.mValueType == AttributeInstruction::kStatus); + } + } + + void DecodeClusterObject(const AttributeInstruction & instruction, const ConcreteAttributePath & path, AttributeCache * cache) + { + std::list statusList; + NL_TEST_ASSERT(gSuite, cache->Get(path.mEndpointId, path.mClusterId, clusterValue, statusList) == CHIP_NO_ERROR); + + if (instruction.mValueType == AttributeInstruction::kData) + { + NL_TEST_ASSERT(gSuite, statusList.size() == 0); + + switch (instruction.mAttributeType) + { + case AttributeInstruction::kAttributeA: + ChipLogProgress(DataManagement, "\t\t -- Validating A (Cluster Obj)"); + NL_TEST_ASSERT(gSuite, clusterValue.int16u == instruction.mInstructionId); + break; + + case AttributeInstruction::kAttributeB: + ChipLogProgress(DataManagement, "\t\t -- Validating B (Cluster Obj)"); + NL_TEST_ASSERT(gSuite, + strncmp((char *) clusterValue.octetString.data(), "hello", clusterValue.octetString.size()) == 0); + break; + + case AttributeInstruction::kAttributeC: + ChipLogProgress(DataManagement, "\t\t -- Validating C (Cluster Obj)"); + NL_TEST_ASSERT(gSuite, clusterValue.structAttr.a == instruction.mInstructionId); + NL_TEST_ASSERT(gSuite, clusterValue.structAttr.b == true); + break; + + case AttributeInstruction::kAttributeD: + ChipLogProgress(DataManagement, "\t\t -- Validating D (Cluster Obj)"); + + auto listIter = clusterValue.listStructOctetString.begin(); + while (listIter.Next()) + { + NL_TEST_ASSERT(gSuite, listIter.GetValue().fabricIndex == instruction.mInstructionId); + } + + NL_TEST_ASSERT(gSuite, listIter.GetStatus() == CHIP_NO_ERROR); + break; + } + } + else + { + NL_TEST_ASSERT(gSuite, statusList.size() == 1); + + auto status = statusList.front(); + NL_TEST_ASSERT(gSuite, status.mPath.mEndpointId == instruction.mEndpointId); + NL_TEST_ASSERT(gSuite, status.mPath.mClusterId == Clusters::TestCluster::Id); + NL_TEST_ASSERT(gSuite, status.mPath.mAttributeId == instruction.GetAttributeId()); + NL_TEST_ASSERT(gSuite, status.mStatus.mStatus == Protocols::InteractionModel::Status::Failure); + } + } + + void OnAttributeChanged(AttributeCache * cache, const ConcreteAttributePath & path) override + { + StatusIB status; + + // Ensure that the provided path is one that we're expecting to find + auto iter = mExpectedAttributes.find(path); + NL_TEST_ASSERT(gSuite, iter != mExpectedAttributes.end()); + + // Once retrieved, let's erase it from the expected set so that we can catch duplicates coming back + // as well as validating that we've seen all attributes at the end. + mExpectedAttributes.erase(iter); + + for (auto & instruction : mInstructionSet) + { + if (instruction.mEndpointId == path.mEndpointId && instruction.GetAttributeId() == path.mAttributeId && + path.mClusterId == Clusters::TestCluster::Id) + { + + // + // Validate both decoding into attribute objects as well as + // cluster objects. + // + DecodeAttribute(instruction, path, cache); + DecodeClusterObject(instruction, path, cache); + } + } + } + + void OnClusterChanged(AttributeCache * cache, EndpointId endpointId, ClusterId clusterId) override + { + auto iter = mExpectedClusters.find(std::make_tuple(endpointId, clusterId)); + NL_TEST_ASSERT(gSuite, iter != mExpectedClusters.end()); + mExpectedClusters.erase(iter); + } + + void OnEndpointAdded(AttributeCache * cache, EndpointId endpointId) override + { + auto iter = mExpectedEndpoints.find(endpointId); + NL_TEST_ASSERT(gSuite, iter != mExpectedEndpoints.end()); + mExpectedEndpoints.erase(iter); + } + + void OnReportEnd(const ReadClient * apReadClient) override + { + NL_TEST_ASSERT(gSuite, mExpectedAttributes.size() == 0); + NL_TEST_ASSERT(gSuite, mExpectedClusters.size() == 0); + NL_TEST_ASSERT(gSuite, mExpectedEndpoints.size() == 0); + } + + // + // We use sets for tracking most of the expected data since we're expecting + // unique data items being provided in the callbacks. + // + std::set mInstructionSet; + std::set mExpectedAttributes; + std::set> mExpectedClusters; + std::set mExpectedEndpoints; +}; + +CacheValidator::CacheValidator(AttributeInstructionListType & instructionList) +{ + for (auto & instruction : instructionList) + { + // + // We need to replace a matching instruction with the latest one we see in the list to ensure we get + // the instruction with the highest InstructionID. Hence the erase and insert (i.e replace) operation. + // + mInstructionSet.erase(instruction); + mInstructionSet.insert(instruction); + mExpectedAttributes.insert( + ConcreteAttributePath(instruction.mEndpointId, Clusters::TestCluster::Id, instruction.GetAttributeId())); + mExpectedClusters.insert(std::make_tuple(instruction.mEndpointId, Clusters::TestCluster::Id)); + mExpectedEndpoints.insert(instruction.mEndpointId); + } +} + +void RunAndValidateSequence(AttributeInstructionListType list) +{ + CacheValidator client(list); + AttributeCache cache(client); + DataSeriesGenerator generator(&cache.GetBufferedCallback(), list); + generator.Generate(); +} + +/* + * This validates the cache by issuing different sequences of attribute combinations + * and ensuring that the latest view in the cache matches up with expectations. + * + * The print statements indicate the expected output. + * + * The legend is as follows: + * + * E1:A1 --- Endpoint 1, Attribute A, Version 1 + * + */ +void TestCache(nlTestSuite * apSuite, void * apContext) +{ + ChipLogProgress(DataManagement, "Validating various sequences of attribute data IBs..."); + + // + // Validate a range of types and ensure that they can be successfully decoded. + // + ChipLogProgress(DataManagement, "E1:A1 --> E1:A1"); + RunAndValidateSequence({ AttributeInstruction( + + AttributeInstruction::kAttributeA, 1, AttributeInstruction::kData) }); + + ChipLogProgress(DataManagement, "E1:B1 --> E1:B1"); + RunAndValidateSequence({ AttributeInstruction( + + AttributeInstruction::kAttributeB, 1, AttributeInstruction::kData) }); + + ChipLogProgress(DataManagement, "E1:C1 --> E1:C1"); + RunAndValidateSequence({ AttributeInstruction(AttributeInstruction::kAttributeC, 1, AttributeInstruction::kData) }); + + ChipLogProgress(DataManagement, "E1:D1 --> E1:D1"); + RunAndValidateSequence({ AttributeInstruction(AttributeInstruction::kAttributeD, 1, AttributeInstruction::kData) }); + + // + // Validate that a newer version of a data item over-rides the + // previous copy. + // + ChipLogProgress(DataManagement, "E1:D1 E1:D2 --> E1:D2"); + RunAndValidateSequence({ AttributeInstruction(AttributeInstruction::kAttributeD, 1, AttributeInstruction::kData), + AttributeInstruction(AttributeInstruction::kAttributeD, 1, AttributeInstruction::kData) }); + + // + // Validate that a newer StatusIB over-rides a previous data value. + // + ChipLogProgress(DataManagement, "E1:D1 E1:D2s --> E1:D2s"); + RunAndValidateSequence({ AttributeInstruction(AttributeInstruction::kAttributeD, 1, AttributeInstruction::kData), + AttributeInstruction(AttributeInstruction::kAttributeD, 1, AttributeInstruction::kStatus) }); + + // + // Validate that a newer data value over-rides a previous status value. + // + ChipLogProgress(DataManagement, "E1:D1s E1:D2 --> E1:D2"); + RunAndValidateSequence({ AttributeInstruction(AttributeInstruction::kAttributeD, 1, AttributeInstruction::kStatus), + AttributeInstruction(AttributeInstruction::kAttributeD, 1, AttributeInstruction::kData) }); + + // + // Validate data across different endpoints. + // + ChipLogProgress(DataManagement, "E0:D1 E1:D2 --> E0:D1 E1:D2"); + RunAndValidateSequence({ AttributeInstruction(AttributeInstruction::kAttributeD, 0, AttributeInstruction::kData), + AttributeInstruction(AttributeInstruction::kAttributeD, 1, AttributeInstruction::kData) }); + + ChipLogProgress(DataManagement, "E0:A1 E0:B2 E0:A3 E0:B4 --> E0:A3 E0:B4"); + RunAndValidateSequence({ AttributeInstruction(AttributeInstruction::kAttributeA, 0, AttributeInstruction::kData), + AttributeInstruction(AttributeInstruction::kAttributeB, 0, AttributeInstruction::kData), + AttributeInstruction(AttributeInstruction::kAttributeA, 0, AttributeInstruction::kData), + AttributeInstruction(AttributeInstruction::kAttributeB, 0, AttributeInstruction::kData) }); +} + +// clang-format off +const nlTest sTests[] = +{ + NL_TEST_DEF("TestCache", TestCache), + NL_TEST_SENTINEL() +}; + +nlTestSuite theSuite = +{ + "TestAttributeCache", + &sTests[0], + TestContext::Initialize, + TestContext::Finalize +}; + +} +// clang-format on + +int TestAttributeCache() +{ + TestContext gContext; + gSuite = &theSuite; + nlTestRunner(&theSuite, &gContext); + return (nlTestRunnerStats(&theSuite)); +} + +CHIP_REGISTER_TEST_SUITE(TestAttributeCache) diff --git a/src/app/zap-templates/templates/app/cluster-objects-src.zapt b/src/app/zap-templates/templates/app/cluster-objects-src.zapt index 51b0c6724aab99..c19740f8cf8ce1 100644 --- a/src/app/zap-templates/templates/app/cluster-objects-src.zapt +++ b/src/app/zap-templates/templates/app/cluster-objects-src.zapt @@ -93,6 +93,23 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader &reader) { {{/zcl_commands}} } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader &reader, const ConcreteAttributePath &path) { + switch (path.mAttributeId) + { +{{#zcl_attributes_server}} + case Attributes::{{asUpperCamelCase label}}::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, {{asLowerCamelCase label}})); + break; +{{/zcl_attributes_server}} + default: + break; + } + + return CHIP_NO_ERROR; +} +} + namespace Events { {{#zcl_events}} namespace {{asUpperCamelCase name}} { diff --git a/src/app/zap-templates/templates/app/cluster-objects.zapt b/src/app/zap-templates/templates/app/cluster-objects.zapt index ac082a2c3f34d0..4057e7c0c8bc1e 100644 --- a/src/app/zap-templates/templates/app/cluster-objects.zapt +++ b/src/app/zap-templates/templates/app/cluster-objects.zapt @@ -163,10 +163,9 @@ public: {{/last}} {{/zcl_commands}} -{{#zcl_attributes_server}} -{{#first}} namespace Attributes { -{{/first}} + +{{#zcl_attributes_server}} namespace {{asUpperCamelCase label}} { struct TypeInfo { {{! forceNotOptional=true because the optionality is on the attribute @@ -186,10 +185,21 @@ namespace {{asUpperCamelCase label}} { static constexpr bool MustUseTimedWrite() { return {{mustUseTimedWrite}}; } }; } // namespace {{asUpperCamelCase label}} -{{#last}} -} // namespace Attributes -{{/last}} {{/zcl_attributes_server}} + +struct TypeInfo +{ + struct DecodableType { + static constexpr ClusterId GetClusterId() { return Clusters::{{asUpperCamelCase name}}::Id; } + + CHIP_ERROR Decode(TLV::TLVReader &reader, const ConcreteAttributePath &path); + +{{#zcl_attributes_server}} + Attributes::{{asUpperCamelCase label}}::TypeInfo::DecodableType {{asLowerCamelCase label}}; +{{/zcl_attributes_server}} + }; +}; +} // namespace Attributes {{#zcl_events}} {{#first}} namespace Events { diff --git a/src/app/zap-templates/zcl/data-model/chip/test-cluster.xml b/src/app/zap-templates/zcl/data-model/chip/test-cluster.xml index 24abf54eafa3a0..a1e563c966a6b9 100644 --- a/src/app/zap-templates/zcl/data-model/chip/test-cluster.xml +++ b/src/app/zap-templates/zcl/data-model/chip/test-cluster.xml @@ -139,7 +139,7 @@ limitations under the License. list_nullables_and_optionals_struct enum_attr - struct + struct_attr range_restricted_int8u range_restricted_int8s range_restricted_int16u diff --git a/src/controller/java/zap-generated/CHIPCallbackTypes.h b/src/controller/java/zap-generated/CHIPCallbackTypes.h index f94266687b19ee..f6f8ee7d56cb4c 100644 --- a/src/controller/java/zap-generated/CHIPCallbackTypes.h +++ b/src/controller/java/zap-generated/CHIPCallbackTypes.h @@ -1031,8 +1031,8 @@ typedef void (*CHIPTestClusterClusterListNullablesAndOptionalsStructAttributeCal void *, const chip::app::Clusters::TestCluster::Attributes::ListNullablesAndOptionalsStruct::TypeInfo::DecodableType &); typedef void (*CHIPTestClusterClusterEnumAttrAttributeCallbackType)( void *, chip::app::Clusters::TestCluster::Attributes::EnumAttr::TypeInfo::DecodableArgType); -typedef void (*CHIPTestClusterClusterStructAttributeCallbackType)( - void *, chip::app::Clusters::TestCluster::Attributes::Struct::TypeInfo::DecodableArgType); +typedef void (*CHIPTestClusterClusterStructAttrAttributeCallbackType)( + void *, chip::app::Clusters::TestCluster::Attributes::StructAttr::TypeInfo::DecodableArgType); typedef void (*CHIPTestClusterClusterRangeRestrictedInt8uAttributeCallbackType)( void *, chip::app::Clusters::TestCluster::Attributes::RangeRestrictedInt8u::TypeInfo::DecodableArgType); typedef void (*CHIPTestClusterClusterRangeRestrictedInt8sAttributeCallbackType)( diff --git a/src/controller/python/chip/clusters/CHIPClusters.py b/src/controller/python/chip/clusters/CHIPClusters.py index 32704cb08376d5..64f998e19348d6 100644 --- a/src/controller/python/chip/clusters/CHIPClusters.py +++ b/src/controller/python/chip/clusters/CHIPClusters.py @@ -4271,7 +4271,7 @@ class ChipClusters: "writable": True, }, 0x00000025: { - "attributeName": "Struct", + "attributeName": "StructAttr", "attributeId": 0x00000025, "type": "", "reportable": True, diff --git a/src/controller/python/chip/clusters/Objects.py b/src/controller/python/chip/clusters/Objects.py index f7e3840c003005..7b17da90f9cd04 100644 --- a/src/controller/python/chip/clusters/Objects.py +++ b/src/controller/python/chip/clusters/Objects.py @@ -29749,7 +29749,7 @@ def descriptor(cls) -> ClusterObjectDescriptor: ClusterObjectFieldDescriptor(Label="vendorId", Tag=0x00000022, Type=uint), ClusterObjectFieldDescriptor(Label="listNullablesAndOptionalsStruct", Tag=0x00000023, Type=typing.List[TestCluster.Structs.NullablesAndOptionalsStruct]), ClusterObjectFieldDescriptor(Label="enumAttr", Tag=0x00000024, Type=TestCluster.Enums.SimpleEnum), - ClusterObjectFieldDescriptor(Label="struct", Tag=0x00000025, Type=TestCluster.Structs.SimpleStruct), + ClusterObjectFieldDescriptor(Label="structAttr", Tag=0x00000025, Type=TestCluster.Structs.SimpleStruct), ClusterObjectFieldDescriptor(Label="rangeRestrictedInt8u", Tag=0x00000026, Type=uint), ClusterObjectFieldDescriptor(Label="rangeRestrictedInt8s", Tag=0x00000027, Type=int), ClusterObjectFieldDescriptor(Label="rangeRestrictedInt16u", Tag=0x00000028, Type=uint), @@ -29832,7 +29832,7 @@ def descriptor(cls) -> ClusterObjectDescriptor: vendorId: 'uint' = None listNullablesAndOptionalsStruct: 'typing.List[TestCluster.Structs.NullablesAndOptionalsStruct]' = None enumAttr: 'TestCluster.Enums.SimpleEnum' = None - struct: 'TestCluster.Structs.SimpleStruct' = None + structAttr: 'TestCluster.Structs.SimpleStruct' = None rangeRestrictedInt8u: 'uint' = None rangeRestrictedInt8s: 'int' = None rangeRestrictedInt16u: 'uint' = None @@ -31186,7 +31186,7 @@ def attribute_type(cls) -> ClusterObjectFieldDescriptor: value: 'TestCluster.Enums.SimpleEnum' = 0 @dataclass - class Struct(ClusterAttributeDescriptor): + class StructAttr(ClusterAttributeDescriptor): @ChipUtility.classproperty def cluster_id(cls) -> int: return 0x050F diff --git a/src/controller/python/test/test_scripts/cluster_objects.py b/src/controller/python/test/test_scripts/cluster_objects.py index 42ecd98becba24..bad51d2a0cab44 100644 --- a/src/controller/python/test/test_scripts/cluster_objects.py +++ b/src/controller/python/test/test_scripts/cluster_objects.py @@ -202,7 +202,7 @@ async def TestReadAttributeRequests(cls, devCtrl): logger.info( f"Basic Cluster - Label: {res[0][Clusters.Basic].productLabel}") logger.info( - f"Test Cluster - Struct: {res[1][Clusters.TestCluster].struct}") + f"Test Cluster - Struct: {res[1][Clusters.TestCluster].structAttr}") logger.info(f"Test Cluster: {res[1][Clusters.TestCluster]}") logger.info("7: Reading Chunked List") diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPAttributeTLVValueDecoder.mm b/src/darwin/Framework/CHIP/zap-generated/CHIPAttributeTLVValueDecoder.mm index dccc4f2ca4a31f..7414561af30c8a 100644 --- a/src/darwin/Framework/CHIP/zap-generated/CHIPAttributeTLVValueDecoder.mm +++ b/src/darwin/Framework/CHIP/zap-generated/CHIPAttributeTLVValueDecoder.mm @@ -6829,8 +6829,8 @@ id CHIPDecodeAttributeValue(const ConcreteAttributePath & aPath, TLV::TLVReader value = [NSNumber numberWithUnsignedChar:chip::to_underlying(cppValue)]; return value; } - case Attributes::Struct::Id: { - using TypeInfo = Attributes::Struct::TypeInfo; + case Attributes::StructAttr::Id: { + using TypeInfo = Attributes::StructAttr::TypeInfo; TypeInfo::DecodableType cppValue; *aError = DataModel::Decode(aReader, cppValue); if (*aError != CHIP_NO_ERROR) { diff --git a/zzz_generated/all-clusters-app/zap-generated/endpoint_config.h b/zzz_generated/all-clusters-app/zap-generated/endpoint_config.h index a04b0fde371fce..f322f1c9534a34 100644 --- a/zzz_generated/all-clusters-app/zap-generated/endpoint_config.h +++ b/zzz_generated/all-clusters-app/zap-generated/endpoint_config.h @@ -2164,7 +2164,7 @@ ZAP_EMPTY_DEFAULT() }, /* list_nullables_and_optionals_struct */ \ { 0x0024, ZAP_TYPE(ENUM8), 1, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_EMPTY_DEFAULT() }, /* enum_attr */ \ { 0x0025, ZAP_TYPE(STRUCT), 0, ZAP_ATTRIBUTE_MASK(EXTERNAL_STORAGE) | ZAP_ATTRIBUTE_MASK(WRITABLE), \ - ZAP_EMPTY_DEFAULT() }, /* struct */ \ + ZAP_EMPTY_DEFAULT() }, /* struct_attr */ \ { 0x0026, ZAP_TYPE(INT8U), 1, ZAP_ATTRIBUTE_MASK(MIN_MAX) | ZAP_ATTRIBUTE_MASK(WRITABLE), \ ZAP_MIN_MAX_DEFAULTS_INDEX(31) }, /* range_restricted_int8u */ \ { 0x0027, ZAP_TYPE(INT8S), 1, ZAP_ATTRIBUTE_MASK(MIN_MAX) | ZAP_ATTRIBUTE_MASK(WRITABLE), \ diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp index 34ad17abae9193..8af4792ee8e875 100644 --- a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp +++ b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp @@ -27,6 +27,199 @@ namespace PowerConfiguration { namespace Commands { } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::MainsVoltage::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, mainsVoltage)); + break; + case Attributes::MainsFrequency::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, mainsFrequency)); + break; + case Attributes::MainsAlarmMask::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, mainsAlarmMask)); + break; + case Attributes::MainsVoltageMinThreshold::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, mainsVoltageMinThreshold)); + break; + case Attributes::MainsVoltageMaxThreshold::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, mainsVoltageMaxThreshold)); + break; + case Attributes::MainsVoltageDwellTrip::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, mainsVoltageDwellTrip)); + break; + case Attributes::BatteryVoltage::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batteryVoltage)); + break; + case Attributes::BatteryPercentageRemaining::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batteryPercentageRemaining)); + break; + case Attributes::BatteryManufacturer::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batteryManufacturer)); + break; + case Attributes::BatterySize::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batterySize)); + break; + case Attributes::BatteryAhrRating::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batteryAhrRating)); + break; + case Attributes::BatteryQuantity::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batteryQuantity)); + break; + case Attributes::BatteryRatedVoltage::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batteryRatedVoltage)); + break; + case Attributes::BatteryAlarmMask::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batteryAlarmMask)); + break; + case Attributes::BatteryVoltageMinThreshold::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batteryVoltageMinThreshold)); + break; + case Attributes::BatteryVoltageThreshold1::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batteryVoltageThreshold1)); + break; + case Attributes::BatteryVoltageThreshold2::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batteryVoltageThreshold2)); + break; + case Attributes::BatteryVoltageThreshold3::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batteryVoltageThreshold3)); + break; + case Attributes::BatteryPercentageMinThreshold::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batteryPercentageMinThreshold)); + break; + case Attributes::BatteryPercentageThreshold1::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batteryPercentageThreshold1)); + break; + case Attributes::BatteryPercentageThreshold2::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batteryPercentageThreshold2)); + break; + case Attributes::BatteryPercentageThreshold3::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batteryPercentageThreshold3)); + break; + case Attributes::BatteryAlarmState::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batteryAlarmState)); + break; + case Attributes::Battery2Voltage::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, battery2Voltage)); + break; + case Attributes::Battery2PercentageRemaining::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, battery2PercentageRemaining)); + break; + case Attributes::Battery2Manufacturer::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, battery2Manufacturer)); + break; + case Attributes::Battery2Size::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, battery2Size)); + break; + case Attributes::Battery2AhrRating::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, battery2AhrRating)); + break; + case Attributes::Battery2Quantity::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, battery2Quantity)); + break; + case Attributes::Battery2RatedVoltage::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, battery2RatedVoltage)); + break; + case Attributes::Battery2AlarmMask::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, battery2AlarmMask)); + break; + case Attributes::Battery2VoltageMinThreshold::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, battery2VoltageMinThreshold)); + break; + case Attributes::Battery2VoltageThreshold1::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, battery2VoltageThreshold1)); + break; + case Attributes::Battery2VoltageThreshold2::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, battery2VoltageThreshold2)); + break; + case Attributes::Battery2VoltageThreshold3::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, battery2VoltageThreshold3)); + break; + case Attributes::Battery2PercentageMinThreshold::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, battery2PercentageMinThreshold)); + break; + case Attributes::Battery2PercentageThreshold1::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, battery2PercentageThreshold1)); + break; + case Attributes::Battery2PercentageThreshold2::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, battery2PercentageThreshold2)); + break; + case Attributes::Battery2PercentageThreshold3::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, battery2PercentageThreshold3)); + break; + case Attributes::Battery2AlarmState::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, battery2AlarmState)); + break; + case Attributes::Battery3Voltage::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, battery3Voltage)); + break; + case Attributes::Battery3PercentageRemaining::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, battery3PercentageRemaining)); + break; + case Attributes::Battery3Manufacturer::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, battery3Manufacturer)); + break; + case Attributes::Battery3Size::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, battery3Size)); + break; + case Attributes::Battery3AhrRating::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, battery3AhrRating)); + break; + case Attributes::Battery3Quantity::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, battery3Quantity)); + break; + case Attributes::Battery3RatedVoltage::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, battery3RatedVoltage)); + break; + case Attributes::Battery3AlarmMask::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, battery3AlarmMask)); + break; + case Attributes::Battery3VoltageMinThreshold::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, battery3VoltageMinThreshold)); + break; + case Attributes::Battery3VoltageThreshold1::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, battery3VoltageThreshold1)); + break; + case Attributes::Battery3VoltageThreshold2::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, battery3VoltageThreshold2)); + break; + case Attributes::Battery3VoltageThreshold3::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, battery3VoltageThreshold3)); + break; + case Attributes::Battery3PercentageMinThreshold::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, battery3PercentageMinThreshold)); + break; + case Attributes::Battery3PercentageThreshold1::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, battery3PercentageThreshold1)); + break; + case Attributes::Battery3PercentageThreshold2::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, battery3PercentageThreshold2)); + break; + case Attributes::Battery3PercentageThreshold3::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, battery3PercentageThreshold3)); + break; + case Attributes::Battery3AlarmState::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, battery3AlarmState)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -36,6 +229,55 @@ namespace DeviceTemperatureConfiguration { namespace Commands { } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::CurrentTemperature::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, currentTemperature)); + break; + case Attributes::MinTempExperienced::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minTempExperienced)); + break; + case Attributes::MaxTempExperienced::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxTempExperienced)); + break; + case Attributes::OverTempTotalDwell::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, overTempTotalDwell)); + break; + case Attributes::DeviceTempAlarmMask::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, deviceTempAlarmMask)); + break; + case Attributes::LowTempThreshold::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, lowTempThreshold)); + break; + case Attributes::HighTempThreshold::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, highTempThreshold)); + break; + case Attributes::LowTempDwellTripPoint::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, lowTempDwellTripPoint)); + break; + case Attributes::HighTempDwellTripPoint::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, highTempDwellTripPoint)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -181,6 +423,34 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, identifyTime)); + break; + case Attributes::IdentifyType::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, identifyType)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -554,6 +824,31 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, nameSupport)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -1431,6 +1726,46 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace CopySceneResponse. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::SceneCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, sceneCount)); + break; + case Attributes::CurrentScene::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, currentScene)); + break; + case Attributes::CurrentGroup::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, currentGroup)); + break; + case Attributes::SceneValid::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, sceneValid)); + break; + case Attributes::NameSupport::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nameSupport)); + break; + case Attributes::LastConfiguredBy::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, lastConfiguredBy)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -1640,6 +1975,43 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, onOff)); + break; + case Attributes::GlobalSceneControl::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, globalSceneControl)); + break; + case Attributes::OnTime::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, onTime)); + break; + case Attributes::OffWaitTime::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, offWaitTime)); + break; + case Attributes::StartUpOnOff::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, startUpOnOff)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -1649,6 +2021,34 @@ namespace OnOffSwitchConfiguration { namespace Commands { } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::SwitchType::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, switchType)); + break; + case Attributes::SwitchActions::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, switchActions)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -1986,6 +2386,70 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace StopWithOnOff. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::CurrentLevel::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, currentLevel)); + break; + case Attributes::RemainingTime::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, remainingTime)); + break; + case Attributes::MinLevel::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minLevel)); + break; + case Attributes::MaxLevel::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxLevel)); + break; + case Attributes::CurrentFrequency::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, currentFrequency)); + break; + case Attributes::MinFrequency::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minFrequency)); + break; + case Attributes::MaxFrequency::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxFrequency)); + break; + case Attributes::Options::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, options)); + break; + case Attributes::OnOffTransitionTime::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, onOffTransitionTime)); + break; + case Attributes::OnLevel::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, onLevel)); + break; + case Attributes::OnTransitionTime::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, onTransitionTime)); + break; + case Attributes::OffTransitionTime::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, offTransitionTime)); + break; + case Attributes::DefaultMoveRate::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, defaultMoveRate)); + break; + case Attributes::StartUpCurrentLevel::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, startUpCurrentLevel)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -2207,6 +2671,31 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace ResetAlarmLog. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::AlarmCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, alarmCount)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -2216,6 +2705,58 @@ namespace Time { namespace Commands { } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::Time::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, time)); + break; + case Attributes::TimeStatus::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, timeStatus)); + break; + case Attributes::TimeZone::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, timeZone)); + break; + case Attributes::DstStart::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, dstStart)); + break; + case Attributes::DstEnd::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, dstEnd)); + break; + case Attributes::DstShift::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, dstShift)); + break; + case Attributes::StandardTime::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, standardTime)); + break; + case Attributes::LocalTime::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, localTime)); + break; + case Attributes::LastSetTime::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, lastSetTime)); + break; + case Attributes::ValidUntilTime::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, validUntilTime)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -2225,6 +2766,55 @@ namespace BinaryInputBasic { namespace Commands { } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::ActiveText::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, activeText)); + break; + case Attributes::Description::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, description)); + break; + case Attributes::InactiveText::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, inactiveText)); + break; + case Attributes::OutOfService::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, outOfService)); + break; + case Attributes::Polarity::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, polarity)); + break; + case Attributes::PresentValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, presentValue)); + break; + case Attributes::Reliability::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, reliability)); + break; + case Attributes::StatusFlags::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, statusFlags)); + break; + case Attributes::ApplicationType::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, applicationType)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -3220,6 +3810,43 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace GetPowerProfilePriceExtended. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::TotalProfileNum::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, totalProfileNum)); + break; + case Attributes::MultipleScheduling::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, multipleScheduling)); + break; + case Attributes::EnergyFormatting::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, energyFormatting)); + break; + case Attributes::EnergyRemote::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, energyRemote)); + break; + case Attributes::ScheduleMode::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, scheduleMode)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -3515,6 +4142,37 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace OverloadWarning. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::StartTime::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, startTime)); + break; + case Attributes::FinishTime::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, finishTime)); + break; + case Attributes::RemainingTime::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, remainingTime)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -3524,6 +4182,28 @@ namespace PulseWidthModulation { namespace Commands { } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -3575,6 +4255,40 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) namespace Commands { } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::DeviceList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, deviceList)); + break; + case Attributes::ServerList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, serverList)); + break; + case Attributes::ClientList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clientList)); + break; + case Attributes::PartsList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, partsList)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -3676,6 +4390,28 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace Unbind. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -3823,6 +4559,34 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) namespace Commands { } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::Acl::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, acl)); + break; + case Attributes::Extension::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, extension)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -4000,6 +4764,49 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace SetShortPollInterval. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::CheckInInterval::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, checkInInterval)); + break; + case Attributes::LongPollInterval::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, longPollInterval)); + break; + case Attributes::ShortPollInterval::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, shortPollInterval)); + break; + case Attributes::FastPollTimeout::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, fastPollTimeout)); + break; + case Attributes::CheckInIntervalMin::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, checkInIntervalMin)); + break; + case Attributes::LongPollIntervalMin::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, longPollIntervalMin)); + break; + case Attributes::FastPollTimeoutMax::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, fastPollTimeoutMax)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -4591,6 +5398,37 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, actionList)); + break; + case Attributes::EndpointList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, endpointList)); + break; + case Attributes::SetupUrl::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, setupUrl)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { namespace StateChanged { CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, TLV::Tag tag) const @@ -4718,6 +5556,85 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace MfgSpecificPing. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::InteractionModelVersion::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, interactionModelVersion)); + break; + case Attributes::VendorName::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, vendorName)); + break; + case Attributes::VendorID::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, vendorID)); + break; + case Attributes::ProductName::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, productName)); + break; + case Attributes::ProductID::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, productID)); + break; + case Attributes::NodeLabel::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nodeLabel)); + break; + case Attributes::Location::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, location)); + break; + case Attributes::HardwareVersion::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, hardwareVersion)); + break; + case Attributes::HardwareVersionString::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, hardwareVersionString)); + break; + case Attributes::SoftwareVersion::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, softwareVersion)); + break; + case Attributes::SoftwareVersionString::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, softwareVersionString)); + break; + case Attributes::ManufacturingDate::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, manufacturingDate)); + break; + case Attributes::PartNumber::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, partNumber)); + break; + case Attributes::ProductURL::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, productURL)); + break; + case Attributes::ProductLabel::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, productLabel)); + break; + case Attributes::SerialNumber::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, serialNumber)); + break; + case Attributes::LocalConfigDisabled::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, localConfigDisabled)); + break; + case Attributes::Reachable::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, reachable)); + break; + case Attributes::UniqueID::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, uniqueID)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { namespace StartUp { CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, TLV::Tag tag) const @@ -5098,6 +6015,28 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace ApplyUpdateResponse. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -5154,6 +6093,34 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace AnnounceOtaProvider. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::DefaultOtaProvider::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, defaultOtaProvider)); + break; + case Attributes::UpdatePossible::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, updatePossible)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { namespace StateTransition { CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, TLV::Tag tag) const @@ -5294,6 +6261,28 @@ namespace LocalizationConfiguration { namespace Commands { } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -5303,6 +6292,28 @@ namespace LocalizationTimeFormat { namespace Commands { } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -5312,6 +6323,28 @@ namespace LocalizationUnit { namespace Commands { } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -5321,6 +6354,31 @@ 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, sources)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -5330,6 +6388,121 @@ namespace PowerSource { 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, status)); + break; + case Attributes::Order::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, order)); + break; + case Attributes::Description::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, description)); + break; + case Attributes::WiredAssessedInputVoltage::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, wiredAssessedInputVoltage)); + break; + case Attributes::WiredAssessedInputFrequency::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, wiredAssessedInputFrequency)); + break; + case Attributes::WiredCurrentType::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, wiredCurrentType)); + break; + case Attributes::WiredAssessedCurrent::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, wiredAssessedCurrent)); + break; + case Attributes::WiredNominalVoltage::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, wiredNominalVoltage)); + break; + case Attributes::WiredMaximumCurrent::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, wiredMaximumCurrent)); + break; + case Attributes::WiredPresent::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, wiredPresent)); + break; + case Attributes::ActiveWiredFaults::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, activeWiredFaults)); + break; + case Attributes::BatteryVoltage::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batteryVoltage)); + break; + case Attributes::BatteryPercentRemaining::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batteryPercentRemaining)); + break; + case Attributes::BatteryTimeRemaining::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batteryTimeRemaining)); + break; + case Attributes::BatteryChargeLevel::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batteryChargeLevel)); + break; + case Attributes::BatteryReplacementNeeded::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batteryReplacementNeeded)); + break; + case Attributes::BatteryReplaceability::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batteryReplaceability)); + break; + case Attributes::BatteryPresent::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batteryPresent)); + break; + case Attributes::ActiveBatteryFaults::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, activeBatteryFaults)); + break; + case Attributes::BatteryReplacementDescription::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batteryReplacementDescription)); + break; + case Attributes::BatteryCommonDesignation::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batteryCommonDesignation)); + break; + case Attributes::BatteryANSIDesignation::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batteryANSIDesignation)); + break; + case Attributes::BatteryIECDesignation::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batteryIECDesignation)); + break; + case Attributes::BatteryApprovedChemistry::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batteryApprovedChemistry)); + break; + case Attributes::BatteryCapacity::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batteryCapacity)); + break; + case Attributes::BatteryQuantity::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batteryQuantity)); + break; + case Attributes::BatteryChargeState::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batteryChargeState)); + break; + case Attributes::BatteryTimeToFullCharge::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batteryTimeToFullCharge)); + break; + case Attributes::BatteryFunctionalWhileCharging::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batteryFunctionalWhileCharging)); + break; + case Attributes::BatteryChargingCurrent::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, batteryChargingCurrent)); + break; + case Attributes::ActiveBatteryChargeFaults::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, activeBatteryChargeFaults)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -5611,6 +6784,40 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace CommissioningCompleteResponse. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::Breadcrumb::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, breadcrumb)); + break; + case Attributes::BasicCommissioningInfoList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, basicCommissioningInfoList)); + break; + case Attributes::RegulatoryConfig::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, regulatoryConfig)); + break; + case Attributes::LocationCapability::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, locationCapability)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -6145,6 +7352,52 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace ReorderNetwork. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::MaxNetworks::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxNetworks)); + break; + case Attributes::Networks::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, networks)); + break; + case Attributes::ScanMaxTimeSeconds::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, scanMaxTimeSeconds)); + break; + case Attributes::ConnectMaxTimeSeconds::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, connectMaxTimeSeconds)); + break; + case Attributes::InterfaceEnabled::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, interfaceEnabled)); + break; + case Attributes::LastNetworkingStatus::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, lastNetworkingStatus)); + break; + case Attributes::LastNetworkID::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, lastNetworkID)); + break; + case Attributes::LastConnectErrorValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, lastConnectErrorValue)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -6243,6 +7496,28 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace RetrieveLogsResponse. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -6312,6 +7587,52 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) namespace Commands { } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::NetworkInterfaces::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, networkInterfaces)); + break; + case Attributes::RebootCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rebootCount)); + break; + case Attributes::UpTime::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, upTime)); + break; + case Attributes::TotalOperationalHours::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, totalOperationalHours)); + break; + case Attributes::BootReasons::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, bootReasons)); + break; + case Attributes::ActiveHardwareFaults::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, activeHardwareFaults)); + break; + case Attributes::ActiveRadioFaults::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, activeRadioFaults)); + break; + case Attributes::ActiveNetworkFaults::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, activeNetworkFaults)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { namespace HardwareFaultChange { CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, TLV::Tag tag) const @@ -6597,6 +7918,40 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, threadMetrics)); + break; + case Attributes::CurrentHeapFree::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, currentHeapFree)); + break; + case Attributes::CurrentHeapUsed::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, currentHeapUsed)); + break; + case Attributes::CurrentHeapHighWatermark::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, currentHeapHighWatermark)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { namespace SoftwareFault { CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, TLV::Tag tag) const @@ -6959,6 +8314,217 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, channel)); + break; + case Attributes::RoutingRole::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, routingRole)); + break; + case Attributes::NetworkName::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, networkName)); + break; + case Attributes::PanId::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, panId)); + break; + case Attributes::ExtendedPanId::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, extendedPanId)); + break; + case Attributes::MeshLocalPrefix::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, meshLocalPrefix)); + break; + case Attributes::OverrunCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, overrunCount)); + break; + case Attributes::NeighborTableList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, neighborTableList)); + break; + case Attributes::RouteTableList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, routeTableList)); + break; + case Attributes::PartitionId::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, partitionId)); + break; + case Attributes::Weighting::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, weighting)); + break; + case Attributes::DataVersion::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, dataVersion)); + break; + case Attributes::StableDataVersion::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, stableDataVersion)); + break; + case Attributes::LeaderRouterId::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, leaderRouterId)); + break; + case Attributes::DetachedRoleCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, detachedRoleCount)); + break; + case Attributes::ChildRoleCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, childRoleCount)); + break; + case Attributes::RouterRoleCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, routerRoleCount)); + break; + case Attributes::LeaderRoleCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, leaderRoleCount)); + break; + case Attributes::AttachAttemptCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attachAttemptCount)); + break; + case Attributes::PartitionIdChangeCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, partitionIdChangeCount)); + break; + case Attributes::BetterPartitionAttachAttemptCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, betterPartitionAttachAttemptCount)); + break; + case Attributes::ParentChangeCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, parentChangeCount)); + break; + case Attributes::TxTotalCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, txTotalCount)); + break; + case Attributes::TxUnicastCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, txUnicastCount)); + break; + case Attributes::TxBroadcastCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, txBroadcastCount)); + break; + case Attributes::TxAckRequestedCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, txAckRequestedCount)); + break; + case Attributes::TxAckedCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, txAckedCount)); + break; + case Attributes::TxNoAckRequestedCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, txNoAckRequestedCount)); + break; + case Attributes::TxDataCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, txDataCount)); + break; + case Attributes::TxDataPollCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, txDataPollCount)); + break; + case Attributes::TxBeaconCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, txBeaconCount)); + break; + case Attributes::TxBeaconRequestCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, txBeaconRequestCount)); + break; + case Attributes::TxOtherCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, txOtherCount)); + break; + case Attributes::TxRetryCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, txRetryCount)); + break; + case Attributes::TxDirectMaxRetryExpiryCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, txDirectMaxRetryExpiryCount)); + break; + case Attributes::TxIndirectMaxRetryExpiryCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, txIndirectMaxRetryExpiryCount)); + break; + case Attributes::TxErrCcaCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, txErrCcaCount)); + break; + case Attributes::TxErrAbortCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, txErrAbortCount)); + break; + case Attributes::TxErrBusyChannelCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, txErrBusyChannelCount)); + break; + case Attributes::RxTotalCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rxTotalCount)); + break; + case Attributes::RxUnicastCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rxUnicastCount)); + break; + case Attributes::RxBroadcastCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rxBroadcastCount)); + break; + case Attributes::RxDataCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rxDataCount)); + break; + case Attributes::RxDataPollCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rxDataPollCount)); + break; + case Attributes::RxBeaconCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rxBeaconCount)); + break; + case Attributes::RxBeaconRequestCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rxBeaconRequestCount)); + break; + case Attributes::RxOtherCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rxOtherCount)); + break; + case Attributes::RxAddressFilteredCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rxAddressFilteredCount)); + break; + case Attributes::RxDestAddrFilteredCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rxDestAddrFilteredCount)); + break; + case Attributes::RxDuplicatedCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rxDuplicatedCount)); + break; + case Attributes::RxErrNoFrameCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rxErrNoFrameCount)); + break; + case Attributes::RxErrUnknownNeighborCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rxErrUnknownNeighborCount)); + break; + case Attributes::RxErrInvalidSrcAddrCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rxErrInvalidSrcAddrCount)); + break; + case Attributes::RxErrSecCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rxErrSecCount)); + break; + case Attributes::RxErrFcsCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rxErrFcsCount)); + break; + case Attributes::RxErrOtherCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rxErrOtherCount)); + break; + case Attributes::ActiveTimestamp::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, activeTimestamp)); + break; + case Attributes::PendingTimestamp::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, pendingTimestamp)); + break; + case Attributes::Delay::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, delay)); + break; + case Attributes::SecurityPolicy::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, securityPolicy)); + break; + case Attributes::ChannelMask::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, channelMask)); + break; + case Attributes::OperationalDatasetComponents::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, operationalDatasetComponents)); + break; + case Attributes::ActiveNetworkFaultsList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, activeNetworkFaultsList)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { namespace ConnectionStatus { CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, TLV::Tag tag) const @@ -7032,6 +8598,67 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, bssid)); + break; + case Attributes::SecurityType::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, securityType)); + break; + case Attributes::WiFiVersion::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, wiFiVersion)); + break; + case Attributes::ChannelNumber::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, channelNumber)); + break; + case Attributes::Rssi::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rssi)); + break; + case Attributes::BeaconLostCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, beaconLostCount)); + break; + case Attributes::BeaconRxCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, beaconRxCount)); + break; + case Attributes::PacketMulticastRxCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, packetMulticastRxCount)); + break; + case Attributes::PacketMulticastTxCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, packetMulticastTxCount)); + break; + case Attributes::PacketUnicastRxCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, packetUnicastRxCount)); + break; + case Attributes::PacketUnicastTxCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, packetUnicastTxCount)); + break; + case Attributes::CurrentMaxRate::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, currentMaxRate)); + break; + case Attributes::OverrunCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, overrunCount)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { namespace Disconnection { CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, TLV::Tag tag) const @@ -7178,6 +8805,55 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, PHYRate)); + break; + case Attributes::FullDuplex::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, fullDuplex)); + break; + case Attributes::PacketRxCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, packetRxCount)); + break; + case Attributes::PacketTxCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, packetTxCount)); + break; + case Attributes::TxErrCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, txErrCount)); + break; + case Attributes::CollisionCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, collisionCount)); + break; + case Attributes::OverrunCount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, overrunCount)); + break; + case Attributes::CarrierDetect::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, carrierDetect)); + break; + case Attributes::TimeSinceReset::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, timeSinceReset)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -7187,6 +8863,28 @@ namespace TimeSynchronization { namespace Commands { } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -7316,6 +9014,73 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace ReachableChanged. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::VendorName::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, vendorName)); + break; + case Attributes::VendorID::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, vendorID)); + break; + case Attributes::ProductName::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, productName)); + break; + case Attributes::NodeLabel::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nodeLabel)); + break; + case Attributes::HardwareVersion::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, hardwareVersion)); + break; + case Attributes::HardwareVersionString::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, hardwareVersionString)); + break; + case Attributes::SoftwareVersion::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, softwareVersion)); + break; + case Attributes::SoftwareVersionString::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, softwareVersionString)); + break; + case Attributes::ManufacturingDate::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, manufacturingDate)); + break; + case Attributes::PartNumber::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, partNumber)); + break; + case Attributes::ProductURL::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, productURL)); + break; + case Attributes::ProductLabel::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, productLabel)); + break; + case Attributes::SerialNumber::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, serialNumber)); + break; + case Attributes::Reachable::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, reachable)); + break; + case Attributes::UniqueID::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, uniqueID)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -7325,6 +9090,37 @@ 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, numberOfPositions)); + break; + case Attributes::CurrentPosition::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, currentPosition)); + break; + case Attributes::MultiPressMax::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, multiPressMax)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { namespace SwitchLatched { CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, TLV::Tag tag) const @@ -7702,6 +9498,37 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, windowStatus)); + break; + case Attributes::AdminFabricIndex::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, adminFabricIndex)); + break; + case Attributes::AdminVendorId::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, adminVendorId)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -8290,6 +10117,43 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace RemoveTrustedRootCertificate. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::FabricsList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, fabricsList)); + break; + case Attributes::SupportedFabrics::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, supportedFabrics)); + break; + case Attributes::CommissionedFabrics::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, commissionedFabrics)); + break; + case Attributes::TrustedRootCertificates::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, trustedRootCertificates)); + break; + case Attributes::CurrentFabricIndex::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, currentFabricIndex)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -8399,6 +10263,34 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) namespace Commands { } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::Groups::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, groups)); + break; + case Attributes::GroupKeys::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, groupKeys)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -8450,6 +10342,31 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, labelList)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -8501,6 +10418,31 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, labelList)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -8510,6 +10452,28 @@ namespace ProxyConfiguration { namespace Commands { } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -8519,6 +10483,28 @@ namespace ProxyDiscovery { namespace Commands { } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -8528,6 +10514,28 @@ namespace ProxyValid { namespace Commands { } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -8537,6 +10545,31 @@ 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, stateValue)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { namespace StateChange { CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, TLV::Tag tag) const @@ -8700,6 +10733,43 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace ChangeToMode. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::CurrentMode::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, currentMode)); + break; + case Attributes::SupportedModes::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, supportedModes)); + break; + case Attributes::OnMode::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, onMode)); + break; + case Attributes::StartUpMode::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, startUpMode)); + break; + case Attributes::Description::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, description)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -8709,6 +10779,43 @@ namespace ShadeConfiguration { namespace Commands { } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::PhysicalClosedLimit::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, physicalClosedLimit)); + break; + case Attributes::MotorStepSize::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, motorStepSize)); + break; + case Attributes::Status::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, status)); + break; + case Attributes::ClosedLimit::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, closedLimit)); + break; + case Attributes::Mode::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, mode)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -10612,6 +12719,163 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace ClearCredential. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::LockState::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, lockState)); + break; + case Attributes::LockType::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, lockType)); + break; + case Attributes::ActuatorEnabled::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, actuatorEnabled)); + break; + case Attributes::DoorState::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, doorState)); + break; + case Attributes::DoorOpenEvents::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, doorOpenEvents)); + break; + case Attributes::DoorClosedEvents::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, doorClosedEvents)); + break; + case Attributes::OpenPeriod::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, openPeriod)); + break; + case Attributes::NumberOfLogRecordsSupported::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, numberOfLogRecordsSupported)); + break; + case Attributes::NumberOfTotalUsersSupported::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, numberOfTotalUsersSupported)); + break; + case Attributes::NumberOfPINUsersSupported::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, numberOfPINUsersSupported)); + break; + case Attributes::NumberOfRFIDUsersSupported::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, numberOfRFIDUsersSupported)); + break; + case Attributes::NumberOfWeekDaySchedulesSupportedPerUser::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, numberOfWeekDaySchedulesSupportedPerUser)); + break; + case Attributes::NumberOfYearDaySchedulesSupportedPerUser::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, numberOfYearDaySchedulesSupportedPerUser)); + break; + case Attributes::NumberOfHolidaySchedulesSupported::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, numberOfHolidaySchedulesSupported)); + break; + case Attributes::MaxPINCodeLength::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxPINCodeLength)); + break; + case Attributes::MinPINCodeLength::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minPINCodeLength)); + break; + case Attributes::MaxRFIDCodeLength::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxRFIDCodeLength)); + break; + case Attributes::MinRFIDCodeLength::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minRFIDCodeLength)); + break; + case Attributes::CredentialRulesSupport::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, credentialRulesSupport)); + break; + case Attributes::EnableLogging::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, enableLogging)); + break; + case Attributes::Language::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, language)); + break; + case Attributes::LEDSettings::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, LEDSettings)); + break; + case Attributes::AutoRelockTime::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, autoRelockTime)); + break; + case Attributes::SoundVolume::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, soundVolume)); + break; + case Attributes::OperatingMode::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, operatingMode)); + break; + case Attributes::SupportedOperatingModes::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, supportedOperatingModes)); + break; + case Attributes::DefaultConfigurationRegister::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, defaultConfigurationRegister)); + break; + case Attributes::EnableLocalProgramming::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, enableLocalProgramming)); + break; + case Attributes::EnableOneTouchLocking::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, enableOneTouchLocking)); + break; + case Attributes::EnableInsideStatusLED::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, enableInsideStatusLED)); + break; + case Attributes::EnablePrivacyModeButton::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, enablePrivacyModeButton)); + break; + case Attributes::LocalProgrammingFeatures::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, localProgrammingFeatures)); + break; + case Attributes::WrongCodeEntryLimit::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, wrongCodeEntryLimit)); + break; + case Attributes::UserCodeTemporaryDisableTime::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, userCodeTemporaryDisableTime)); + break; + case Attributes::SendPINOverTheAir::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, sendPINOverTheAir)); + break; + case Attributes::RequirePINforRemoteOperation::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, requirePINforRemoteOperation)); + break; + case Attributes::ExpiringUserTimeout::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, expiringUserTimeout)); + break; + case Attributes::AlarmMask::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, alarmMask)); + break; + case Attributes::KeypadOperationEventMask::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, keypadOperationEventMask)); + break; + case Attributes::RemoteOperationEventMask::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, remoteOperationEventMask)); + break; + case Attributes::ManualOperationEventMask::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, manualOperationEventMask)); + break; + case Attributes::RFIDOperationEventMask::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, RFIDOperationEventMask)); + break; + case Attributes::KeypadProgrammingEventMask::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, keypadProgrammingEventMask)); + break; + case Attributes::RemoteProgrammingEventMask::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, remoteProgrammingEventMask)); + break; + case Attributes::RFIDProgrammingEventMask::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, RFIDProgrammingEventMask)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { namespace DoorLockAlarm { CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, TLV::Tag tag) const @@ -11097,6 +13361,109 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, type)); + break; + case Attributes::PhysicalClosedLimitLift::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, physicalClosedLimitLift)); + break; + case Attributes::PhysicalClosedLimitTilt::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, physicalClosedLimitTilt)); + break; + case Attributes::CurrentPositionLift::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, currentPositionLift)); + break; + case Attributes::CurrentPositionTilt::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, currentPositionTilt)); + break; + case Attributes::NumberOfActuationsLift::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, numberOfActuationsLift)); + break; + case Attributes::NumberOfActuationsTilt::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, numberOfActuationsTilt)); + break; + case Attributes::ConfigStatus::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, configStatus)); + break; + case Attributes::CurrentPositionLiftPercentage::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, currentPositionLiftPercentage)); + break; + case Attributes::CurrentPositionTiltPercentage::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, currentPositionTiltPercentage)); + break; + case Attributes::OperationalStatus::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, operationalStatus)); + break; + case Attributes::TargetPositionLiftPercent100ths::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, targetPositionLiftPercent100ths)); + break; + case Attributes::TargetPositionTiltPercent100ths::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, targetPositionTiltPercent100ths)); + break; + case Attributes::EndProductType::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, endProductType)); + break; + case Attributes::CurrentPositionLiftPercent100ths::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, currentPositionLiftPercent100ths)); + break; + case Attributes::CurrentPositionTiltPercent100ths::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, currentPositionTiltPercent100ths)); + break; + case Attributes::InstalledOpenLimitLift::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, installedOpenLimitLift)); + break; + case Attributes::InstalledClosedLimitLift::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, installedClosedLimitLift)); + break; + case Attributes::InstalledOpenLimitTilt::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, installedOpenLimitTilt)); + break; + case Attributes::InstalledClosedLimitTilt::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, installedClosedLimitTilt)); + break; + case Attributes::VelocityLift::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, velocityLift)); + break; + case Attributes::AccelerationTimeLift::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, accelerationTimeLift)); + break; + case Attributes::DecelerationTimeLift::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, decelerationTimeLift)); + break; + case Attributes::Mode::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, mode)); + break; + case Attributes::IntermediateSetpointsLift::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, intermediateSetpointsLift)); + break; + case Attributes::IntermediateSetpointsTilt::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, intermediateSetpointsTilt)); + break; + case Attributes::SafetyStatus::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, safetyStatus)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -11170,6 +13537,58 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace BarrierControlStop. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::BarrierMovingState::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, barrierMovingState)); + break; + case Attributes::BarrierSafetyStatus::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, barrierSafetyStatus)); + break; + case Attributes::BarrierCapabilities::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, barrierCapabilities)); + break; + case Attributes::BarrierOpenEvents::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, barrierOpenEvents)); + break; + case Attributes::BarrierCloseEvents::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, barrierCloseEvents)); + break; + case Attributes::BarrierCommandOpenEvents::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, barrierCommandOpenEvents)); + break; + case Attributes::BarrierCommandCloseEvents::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, barrierCommandCloseEvents)); + break; + case Attributes::BarrierOpenPeriod::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, barrierOpenPeriod)); + break; + case Attributes::BarrierClosePeriod::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, barrierClosePeriod)); + break; + case Attributes::BarrierPosition::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, barrierPosition)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -11179,6 +13598,100 @@ 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxPressure)); + break; + case Attributes::MaxSpeed::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxSpeed)); + break; + case Attributes::MaxFlow::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxFlow)); + break; + case Attributes::MinConstPressure::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minConstPressure)); + break; + case Attributes::MaxConstPressure::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxConstPressure)); + break; + case Attributes::MinCompPressure::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minCompPressure)); + break; + case Attributes::MaxCompPressure::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxCompPressure)); + break; + case Attributes::MinConstSpeed::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minConstSpeed)); + break; + case Attributes::MaxConstSpeed::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxConstSpeed)); + break; + case Attributes::MinConstFlow::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minConstFlow)); + break; + case Attributes::MaxConstFlow::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxConstFlow)); + break; + case Attributes::MinConstTemp::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minConstTemp)); + break; + case Attributes::MaxConstTemp::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxConstTemp)); + break; + case Attributes::PumpStatus::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, pumpStatus)); + break; + case Attributes::EffectiveOperationMode::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, effectiveOperationMode)); + break; + case Attributes::EffectiveControlMode::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, effectiveControlMode)); + break; + case Attributes::Capacity::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, capacity)); + break; + case Attributes::Speed::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, speed)); + break; + case Attributes::LifetimeRunningHours::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, lifetimeRunningHours)); + break; + case Attributes::Power::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, power)); + break; + case Attributes::LifetimeEnergyConsumed::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, lifetimeEnergyConsumed)); + break; + case Attributes::OperationMode::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, operationMode)); + break; + case Attributes::ControlMode::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, controlMode)); + break; + case Attributes::AlarmMask::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, alarmMask)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { namespace SupplyVoltageLow { CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, TLV::Tag tag) const @@ -11985,6 +14498,157 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace GetRelayStatusLog. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::LocalTemperature::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, localTemperature)); + break; + case Attributes::OutdoorTemperature::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, outdoorTemperature)); + break; + case Attributes::Occupancy::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, occupancy)); + break; + case Attributes::AbsMinHeatSetpointLimit::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, absMinHeatSetpointLimit)); + break; + case Attributes::AbsMaxHeatSetpointLimit::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, absMaxHeatSetpointLimit)); + break; + case Attributes::AbsMinCoolSetpointLimit::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, absMinCoolSetpointLimit)); + break; + case Attributes::AbsMaxCoolSetpointLimit::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, absMaxCoolSetpointLimit)); + break; + case Attributes::PiCoolingDemand::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, piCoolingDemand)); + break; + case Attributes::PiHeatingDemand::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, piHeatingDemand)); + break; + case Attributes::HvacSystemTypeConfiguration::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, hvacSystemTypeConfiguration)); + break; + case Attributes::LocalTemperatureCalibration::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, localTemperatureCalibration)); + break; + case Attributes::OccupiedCoolingSetpoint::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, occupiedCoolingSetpoint)); + break; + case Attributes::OccupiedHeatingSetpoint::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, occupiedHeatingSetpoint)); + break; + case Attributes::UnoccupiedCoolingSetpoint::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, unoccupiedCoolingSetpoint)); + break; + case Attributes::UnoccupiedHeatingSetpoint::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, unoccupiedHeatingSetpoint)); + break; + case Attributes::MinHeatSetpointLimit::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minHeatSetpointLimit)); + break; + case Attributes::MaxHeatSetpointLimit::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxHeatSetpointLimit)); + break; + case Attributes::MinCoolSetpointLimit::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minCoolSetpointLimit)); + break; + case Attributes::MaxCoolSetpointLimit::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxCoolSetpointLimit)); + break; + case Attributes::MinSetpointDeadBand::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minSetpointDeadBand)); + break; + case Attributes::RemoteSensing::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, remoteSensing)); + break; + case Attributes::ControlSequenceOfOperation::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, controlSequenceOfOperation)); + break; + case Attributes::SystemMode::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, systemMode)); + break; + case Attributes::AlarmMask::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, alarmMask)); + break; + case Attributes::ThermostatRunningMode::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, thermostatRunningMode)); + break; + case Attributes::StartOfWeek::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, startOfWeek)); + break; + case Attributes::NumberOfWeeklyTransitions::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, numberOfWeeklyTransitions)); + break; + case Attributes::NumberOfDailyTransitions::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, numberOfDailyTransitions)); + break; + case Attributes::TemperatureSetpointHold::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, temperatureSetpointHold)); + break; + case Attributes::TemperatureSetpointHoldDuration::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, temperatureSetpointHoldDuration)); + break; + case Attributes::ThermostatProgrammingOperationMode::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, thermostatProgrammingOperationMode)); + break; + case Attributes::ThermostatRunningState::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, thermostatRunningState)); + break; + case Attributes::SetpointChangeSource::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, setpointChangeSource)); + break; + case Attributes::SetpointChangeAmount::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, setpointChangeAmount)); + break; + case Attributes::SetpointChangeSourceTimestamp::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, setpointChangeSourceTimestamp)); + break; + case Attributes::AcType::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, acType)); + break; + case Attributes::AcCapacity::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, acCapacity)); + break; + case Attributes::AcRefrigerantType::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, acRefrigerantType)); + break; + case Attributes::AcCompressor::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, acCompressor)); + break; + case Attributes::AcErrorCode::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, acErrorCode)); + break; + case Attributes::AcLouverPosition::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, acLouverPosition)); + break; + case Attributes::AcCoilTemperature::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, acCoilTemperature)); + break; + case Attributes::AcCapacityFormat::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, acCapacityFormat)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -11994,6 +14658,34 @@ namespace FanControl { namespace Commands { } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::FanMode::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, fanMode)); + break; + case Attributes::FanModeSequence::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, fanModeSequence)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -12003,6 +14695,52 @@ namespace DehumidificationControl { namespace Commands { } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::RelativeHumidity::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, relativeHumidity)); + break; + case Attributes::DehumidificationCooling::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, dehumidificationCooling)); + break; + case Attributes::RhDehumidificationSetpoint::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rhDehumidificationSetpoint)); + break; + case Attributes::RelativeHumidityMode::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, relativeHumidityMode)); + break; + case Attributes::DehumidificationLockout::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, dehumidificationLockout)); + break; + case Attributes::DehumidificationHysteresis::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, dehumidificationHysteresis)); + break; + case Attributes::DehumidificationMaxCool::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, dehumidificationMaxCool)); + break; + case Attributes::RelativeHumidityDisplay::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, relativeHumidityDisplay)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -12012,6 +14750,37 @@ 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, temperatureDisplayMode)); + break; + case Attributes::KeypadLockout::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, keypadLockout)); + break; + case Attributes::ScheduleProgrammingVisibility::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, scheduleProgrammingVisibility)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -12959,6 +15728,184 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, currentHue)); + break; + case Attributes::CurrentSaturation::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, currentSaturation)); + break; + case Attributes::RemainingTime::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, remainingTime)); + break; + case Attributes::CurrentX::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, currentX)); + break; + case Attributes::CurrentY::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, currentY)); + break; + case Attributes::DriftCompensation::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, driftCompensation)); + break; + case Attributes::CompensationText::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, compensationText)); + break; + case Attributes::ColorTemperature::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, colorTemperature)); + break; + case Attributes::ColorMode::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, colorMode)); + break; + case Attributes::ColorControlOptions::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, colorControlOptions)); + break; + case Attributes::NumberOfPrimaries::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, numberOfPrimaries)); + break; + case Attributes::Primary1X::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, primary1X)); + break; + case Attributes::Primary1Y::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, primary1Y)); + break; + case Attributes::Primary1Intensity::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, primary1Intensity)); + break; + case Attributes::Primary2X::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, primary2X)); + break; + case Attributes::Primary2Y::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, primary2Y)); + break; + case Attributes::Primary2Intensity::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, primary2Intensity)); + break; + case Attributes::Primary3X::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, primary3X)); + break; + case Attributes::Primary3Y::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, primary3Y)); + break; + case Attributes::Primary3Intensity::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, primary3Intensity)); + break; + case Attributes::Primary4X::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, primary4X)); + break; + case Attributes::Primary4Y::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, primary4Y)); + break; + case Attributes::Primary4Intensity::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, primary4Intensity)); + break; + case Attributes::Primary5X::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, primary5X)); + break; + case Attributes::Primary5Y::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, primary5Y)); + break; + case Attributes::Primary5Intensity::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, primary5Intensity)); + break; + case Attributes::Primary6X::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, primary6X)); + break; + case Attributes::Primary6Y::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, primary6Y)); + break; + case Attributes::Primary6Intensity::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, primary6Intensity)); + break; + case Attributes::WhitePointX::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, whitePointX)); + break; + case Attributes::WhitePointY::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, whitePointY)); + break; + case Attributes::ColorPointRX::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, colorPointRX)); + break; + case Attributes::ColorPointRY::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, colorPointRY)); + break; + case Attributes::ColorPointRIntensity::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, colorPointRIntensity)); + break; + case Attributes::ColorPointGX::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, colorPointGX)); + break; + case Attributes::ColorPointGY::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, colorPointGY)); + break; + case Attributes::ColorPointGIntensity::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, colorPointGIntensity)); + break; + case Attributes::ColorPointBX::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, colorPointBX)); + break; + case Attributes::ColorPointBY::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, colorPointBY)); + break; + case Attributes::ColorPointBIntensity::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, colorPointBIntensity)); + break; + case Attributes::EnhancedCurrentHue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, enhancedCurrentHue)); + break; + case Attributes::EnhancedColorMode::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, enhancedColorMode)); + break; + case Attributes::ColorLoopActive::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, colorLoopActive)); + break; + case Attributes::ColorLoopDirection::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, colorLoopDirection)); + break; + case Attributes::ColorLoopTime::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, colorLoopTime)); + break; + case Attributes::ColorLoopStartEnhancedHue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, colorLoopStartEnhancedHue)); + break; + case Attributes::ColorLoopStoredEnhancedHue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, colorLoopStoredEnhancedHue)); + break; + case Attributes::ColorCapabilities::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, colorCapabilities)); + break; + case Attributes::ColorTempPhysicalMin::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, colorTempPhysicalMin)); + break; + case Attributes::ColorTempPhysicalMax::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, colorTempPhysicalMax)); + break; + case Attributes::CoupleColorTempToLevelMinMireds::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, coupleColorTempToLevelMinMireds)); + break; + case Attributes::StartUpColorTemperatureMireds::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, startUpColorTemperatureMireds)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -12968,6 +15915,76 @@ 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, physicalMinLevel)); + break; + case Attributes::PhysicalMaxLevel::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, physicalMaxLevel)); + break; + case Attributes::BallastStatus::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, ballastStatus)); + break; + case Attributes::MinLevel::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minLevel)); + break; + case Attributes::MaxLevel::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxLevel)); + break; + case Attributes::PowerOnLevel::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, powerOnLevel)); + break; + case Attributes::PowerOnFadeTime::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, powerOnFadeTime)); + break; + case Attributes::IntrinsicBallastFactor::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, intrinsicBallastFactor)); + break; + case Attributes::BallastFactorAdjustment::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, ballastFactorAdjustment)); + break; + case Attributes::LampQuality::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, lampQuality)); + break; + case Attributes::LampType::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, lampType)); + break; + case Attributes::LampManufacturer::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, lampManufacturer)); + break; + case Attributes::LampRatedHours::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, lampRatedHours)); + break; + case Attributes::LampBurnHours::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, lampBurnHours)); + break; + case Attributes::LampAlarmMode::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, lampAlarmMode)); + break; + case Attributes::LampBurnHoursTripPoint::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, lampBurnHoursTripPoint)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -12977,6 +15994,43 @@ 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::LightSensorType::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, lightSensorType)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -12986,6 +16040,40 @@ 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -12995,6 +16083,55 @@ 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::ScaledValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, scaledValue)); + break; + case Attributes::MinScaledValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minScaledValue)); + break; + case Attributes::MaxScaledValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxScaledValue)); + break; + case Attributes::ScaledTolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, scaledTolerance)); + break; + case Attributes::Scale::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, scale)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -13004,8 +16141,42 @@ namespace FlowMeasurement { namespace Commands { } // namespace Commands -namespace Events { -} // namespace Events +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::MeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + +namespace Events { +} // namespace Events } // namespace FlowMeasurement namespace RelativeHumidityMeasurement { @@ -13013,6 +16184,40 @@ 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -13022,6 +16227,64 @@ namespace OccupancySensing { 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, occupancy)); + break; + case Attributes::OccupancySensorType::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, occupancySensorType)); + break; + case Attributes::OccupancySensorTypeBitmap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, occupancySensorTypeBitmap)); + break; + case Attributes::PirOccupiedToUnoccupiedDelay::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, pirOccupiedToUnoccupiedDelay)); + break; + case Attributes::PirUnoccupiedToOccupiedDelay::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, pirUnoccupiedToOccupiedDelay)); + break; + case Attributes::PirUnoccupiedToOccupiedThreshold::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, pirUnoccupiedToOccupiedThreshold)); + break; + case Attributes::UltrasonicOccupiedToUnoccupiedDelay::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, ultrasonicOccupiedToUnoccupiedDelay)); + break; + case Attributes::UltrasonicUnoccupiedToOccupiedDelay::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, ultrasonicUnoccupiedToOccupiedDelay)); + break; + case Attributes::UltrasonicUnoccupiedToOccupiedThreshold::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, ultrasonicUnoccupiedToOccupiedThreshold)); + break; + case Attributes::PhysicalContactOccupiedToUnoccupiedDelay::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, physicalContactOccupiedToUnoccupiedDelay)); + break; + case Attributes::PhysicalContactUnoccupiedToOccupiedDelay::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, physicalContactUnoccupiedToOccupiedDelay)); + break; + case Attributes::PhysicalContactUnoccupiedToOccupiedThreshold::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, physicalContactUnoccupiedToOccupiedThreshold)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -13031,6 +16294,40 @@ 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -13040,6 +16337,40 @@ 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -13049,6 +16380,40 @@ namespace EthyleneConcentrationMeasurement { 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -13058,6 +16423,40 @@ namespace EthyleneOxideConcentrationMeasurement { 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -13067,6 +16466,40 @@ namespace HydrogenConcentrationMeasurement { 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -13076,6 +16509,40 @@ namespace HydrogenSulphideConcentrationMeasurement { 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -13085,6 +16552,40 @@ namespace NitricOxideConcentrationMeasurement { 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -13094,6 +16595,40 @@ 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -13103,6 +16638,40 @@ namespace OxygenConcentrationMeasurement { 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -13112,6 +16681,40 @@ 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -13121,6 +16724,40 @@ namespace SulfurDioxideConcentrationMeasurement { 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -13130,6 +16767,40 @@ namespace DissolvedOxygenConcentrationMeasurement { 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -13139,6 +16810,40 @@ namespace BromateConcentrationMeasurement { 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -13148,6 +16853,40 @@ namespace ChloraminesConcentrationMeasurement { 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -13157,6 +16896,40 @@ namespace ChlorineConcentrationMeasurement { 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -13166,6 +16939,40 @@ namespace FecalColiformAndEColiConcentrationMeasurement { 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -13175,6 +16982,40 @@ namespace FluorideConcentrationMeasurement { 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -13184,6 +17025,40 @@ namespace HaloaceticAcidsConcentrationMeasurement { 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -13193,6 +17068,40 @@ namespace TotalTrihalomethanesConcentrationMeasurement { 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -13202,6 +17111,40 @@ namespace TotalColiformBacteriaConcentrationMeasurement { 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -13211,6 +17154,40 @@ namespace TurbidityConcentrationMeasurement { 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -13220,6 +17197,40 @@ namespace CopperConcentrationMeasurement { 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -13229,6 +17240,40 @@ namespace LeadConcentrationMeasurement { 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -13238,6 +17283,40 @@ namespace ManganeseConcentrationMeasurement { 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -13247,6 +17326,40 @@ namespace SulfateConcentrationMeasurement { 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -13256,6 +17369,40 @@ namespace BromodichloromethaneConcentrationMeasurement { 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -13265,6 +17412,40 @@ namespace BromoformConcentrationMeasurement { 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -13274,6 +17455,40 @@ namespace ChlorodibromomethaneConcentrationMeasurement { 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -13283,6 +17498,40 @@ namespace ChloroformConcentrationMeasurement { 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -13292,6 +17541,40 @@ namespace SodiumConcentrationMeasurement { 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(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredValue)); + break; + case Attributes::MinMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, minMeasuredValue)); + break; + case Attributes::MaxMeasuredValue::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxMeasuredValue)); + break; + case Attributes::Tolerance::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, tolerance)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -13553,6 +17836,49 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace InitiateTestModeResponse. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::ZoneState::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, zoneState)); + break; + case Attributes::ZoneType::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, zoneType)); + break; + case Attributes::ZoneStatus::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, zoneStatus)); + break; + case Attributes::IasCieAddress::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, iasCieAddress)); + break; + case Attributes::ZoneId::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, zoneId)); + break; + case Attributes::NumberOfZoneSensitivityLevelsSupported::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, numberOfZoneSensitivityLevelsSupported)); + break; + case Attributes::CurrentZoneSensitivityLevel::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, currentZoneSensitivityLevel)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -14384,6 +18710,28 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace GetZoneStatus. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -14473,6 +18821,31 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace Squawk. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::MaxDuration::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, maxDuration)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -14482,6 +18855,31 @@ namespace WakeOnLan { namespace Commands { } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::WakeOnLanMacAddress::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, wakeOnLanMacAddress)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -14737,6 +19135,37 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace SkipChannel. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::ChannelList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, channelList)); + break; + case Attributes::ChannelLineup::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, channelLineup)); + break; + case Attributes::CurrentChannel::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, currentChannel)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -14864,6 +19293,34 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace NavigateTargetResponse. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::TargetNavigatorList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, targetNavigatorList)); + break; + case Attributes::CurrentNavigatorTarget::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, currentNavigatorTarget)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -15644,6 +20101,49 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace MediaSeekResponse. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::PlaybackState::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, playbackState)); + break; + case Attributes::StartTime::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, startTime)); + break; + case Attributes::Duration::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, duration)); + break; + case Attributes::Position::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, position)); + break; + case Attributes::PlaybackSpeed::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, playbackSpeed)); + break; + case Attributes::SeekRangeEnd::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, seekRangeEnd)); + break; + case Attributes::SeekRangeStart::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, seekRangeStart)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -15835,6 +20335,34 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace RenameInput. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::MediaInputList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, mediaInputList)); + break; + case Attributes::CurrentMediaInput::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, currentMediaInput)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -15874,6 +20402,28 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace Sleep. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -15951,6 +20501,28 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace SendKeyResponse. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -16353,6 +20925,34 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace LaunchURLResponse. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::AcceptsHeaderList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, acceptsHeaderList)); + break; + case Attributes::SupportedStreamingProtocols::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, supportedStreamingProtocols)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -16480,6 +21080,34 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace RenameOutput. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::AudioOutputList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, audioOutputList)); + break; + case Attributes::CurrentAudioOutput::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, currentAudioOutput)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -16791,6 +21419,34 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace HideAppResponse. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::ApplicationLauncherList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, applicationLauncherList)); + break; + case Attributes::ApplicationLauncherApp::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, applicationLauncherApp)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -16876,6 +21532,49 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace ChangeStatus. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::VendorName::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, vendorName)); + break; + case Attributes::VendorId::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, vendorId)); + break; + case Attributes::ApplicationName::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, applicationName)); + break; + case Attributes::ProductId::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, productId)); + break; + case Attributes::ApplicationApp::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, applicationApp)); + break; + case Attributes::ApplicationStatus::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, applicationStatus)); + break; + case Attributes::ApplicationVersion::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, applicationVersion)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -17023,6 +21722,28 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace Logout. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -18682,6 +23403,262 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace TestEmitTestEventRequest. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::Boolean::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, boolean)); + break; + case Attributes::Bitmap8::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, bitmap8)); + break; + case Attributes::Bitmap16::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, bitmap16)); + break; + case Attributes::Bitmap32::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, bitmap32)); + break; + case Attributes::Bitmap64::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, bitmap64)); + break; + case Attributes::Int8u::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, int8u)); + break; + case Attributes::Int16u::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, int16u)); + break; + case Attributes::Int24u::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, int24u)); + break; + case Attributes::Int32u::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, int32u)); + break; + case Attributes::Int40u::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, int40u)); + break; + case Attributes::Int48u::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, int48u)); + break; + case Attributes::Int56u::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, int56u)); + break; + case Attributes::Int64u::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, int64u)); + break; + case Attributes::Int8s::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, int8s)); + break; + case Attributes::Int16s::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, int16s)); + break; + case Attributes::Int24s::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, int24s)); + break; + case Attributes::Int32s::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, int32s)); + break; + case Attributes::Int40s::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, int40s)); + break; + case Attributes::Int48s::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, int48s)); + break; + case Attributes::Int56s::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, int56s)); + break; + case Attributes::Int64s::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, int64s)); + break; + case Attributes::Enum8::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, enum8)); + break; + case Attributes::Enum16::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, enum16)); + break; + case Attributes::FloatSingle::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, floatSingle)); + break; + case Attributes::FloatDouble::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, floatDouble)); + break; + case Attributes::OctetString::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, octetString)); + break; + case Attributes::ListInt8u::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, listInt8u)); + break; + case Attributes::ListOctetString::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, listOctetString)); + break; + case Attributes::ListStructOctetString::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, listStructOctetString)); + break; + case Attributes::LongOctetString::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, longOctetString)); + break; + case Attributes::CharString::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, charString)); + break; + case Attributes::LongCharString::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, longCharString)); + break; + case Attributes::EpochUs::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, epochUs)); + break; + case Attributes::EpochS::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, epochS)); + break; + case Attributes::VendorId::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, vendorId)); + break; + case Attributes::ListNullablesAndOptionalsStruct::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, listNullablesAndOptionalsStruct)); + break; + case Attributes::EnumAttr::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, enumAttr)); + break; + case Attributes::StructAttr::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, structAttr)); + break; + case Attributes::RangeRestrictedInt8u::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rangeRestrictedInt8u)); + break; + case Attributes::RangeRestrictedInt8s::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rangeRestrictedInt8s)); + break; + case Attributes::RangeRestrictedInt16u::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rangeRestrictedInt16u)); + break; + case Attributes::RangeRestrictedInt16s::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rangeRestrictedInt16s)); + break; + case Attributes::ListLongOctetString::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, listLongOctetString)); + break; + case Attributes::TimedWriteBoolean::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, timedWriteBoolean)); + break; + case Attributes::Unsupported::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, unsupported)); + break; + case Attributes::NullableBoolean::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nullableBoolean)); + break; + case Attributes::NullableBitmap8::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nullableBitmap8)); + break; + case Attributes::NullableBitmap16::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nullableBitmap16)); + break; + case Attributes::NullableBitmap32::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nullableBitmap32)); + break; + case Attributes::NullableBitmap64::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nullableBitmap64)); + break; + case Attributes::NullableInt8u::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nullableInt8u)); + break; + case Attributes::NullableInt16u::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nullableInt16u)); + break; + case Attributes::NullableInt24u::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nullableInt24u)); + break; + case Attributes::NullableInt32u::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nullableInt32u)); + break; + case Attributes::NullableInt40u::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nullableInt40u)); + break; + case Attributes::NullableInt48u::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nullableInt48u)); + break; + case Attributes::NullableInt56u::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nullableInt56u)); + break; + case Attributes::NullableInt64u::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nullableInt64u)); + break; + case Attributes::NullableInt8s::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nullableInt8s)); + break; + case Attributes::NullableInt16s::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nullableInt16s)); + break; + case Attributes::NullableInt24s::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nullableInt24s)); + break; + case Attributes::NullableInt32s::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nullableInt32s)); + break; + case Attributes::NullableInt40s::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nullableInt40s)); + break; + case Attributes::NullableInt48s::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nullableInt48s)); + break; + case Attributes::NullableInt56s::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nullableInt56s)); + break; + case Attributes::NullableInt64s::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nullableInt64s)); + break; + case Attributes::NullableEnum8::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nullableEnum8)); + break; + case Attributes::NullableEnum16::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nullableEnum16)); + break; + case Attributes::NullableFloatSingle::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nullableFloatSingle)); + break; + case Attributes::NullableFloatDouble::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nullableFloatDouble)); + break; + case Attributes::NullableOctetString::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nullableOctetString)); + break; + case Attributes::NullableCharString::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nullableCharString)); + break; + case Attributes::NullableEnumAttr::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nullableEnumAttr)); + break; + case Attributes::NullableStruct::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nullableStruct)); + break; + case Attributes::NullableRangeRestrictedInt8u::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nullableRangeRestrictedInt8u)); + break; + case Attributes::NullableRangeRestrictedInt8s::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nullableRangeRestrictedInt8s)); + break; + case Attributes::NullableRangeRestrictedInt16u::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nullableRangeRestrictedInt16u)); + break; + case Attributes::NullableRangeRestrictedInt16s::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, nullableRangeRestrictedInt16s)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { namespace TestEvent { CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, TLV::Tag tag) const @@ -19040,6 +24017,28 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace CancelAllMessages. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -19049,6 +24048,64 @@ namespace ApplianceIdentification { namespace Commands { } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::BasicIdentification::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, basicIdentification)); + break; + case Attributes::CompanyName::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, companyName)); + break; + case Attributes::CompanyId::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, companyId)); + break; + case Attributes::BrandName::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, brandName)); + break; + case Attributes::BrandId::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, brandId)); + break; + case Attributes::Model::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, model)); + break; + case Attributes::PartNumber::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, partNumber)); + break; + case Attributes::ProductRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, productRevision)); + break; + case Attributes::SoftwareRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, softwareRevision)); + break; + case Attributes::ProductTypeName::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, productTypeName)); + break; + case Attributes::ProductTypeId::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, productTypeId)); + break; + case Attributes::CecedSpecificationVersion::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, cecedSpecificationVersion)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -19058,6 +24115,64 @@ namespace MeterIdentification { namespace Commands { } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::CompanyName::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, companyName)); + break; + case Attributes::MeterTypeId::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, meterTypeId)); + break; + case Attributes::DataQualityId::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, dataQualityId)); + break; + case Attributes::CustomerName::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, customerName)); + break; + case Attributes::Model::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, model)); + break; + case Attributes::PartNumber::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, partNumber)); + break; + case Attributes::ProductRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, productRevision)); + break; + case Attributes::SoftwareRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, softwareRevision)); + break; + case Attributes::UtilityName::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, utilityName)); + break; + case Attributes::Pod::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, pod)); + break; + case Attributes::AvailablePower::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, availablePower)); + break; + case Attributes::PowerThreshold::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, powerThreshold)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -19211,6 +24326,28 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace EventsNotification. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -19452,6 +24589,34 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace StatisticsAvailable. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::LogMaxSize::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, logMaxSize)); + break; + case Attributes::LogQueueMaxSize::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, logQueueMaxSize)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events @@ -19637,6 +24802,412 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace GetMeasurementProfileCommand. } // namespace Commands +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::MeasurementType::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, measurementType)); + break; + case Attributes::DcVoltage::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, dcVoltage)); + break; + case Attributes::DcVoltageMin::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, dcVoltageMin)); + break; + case Attributes::DcVoltageMax::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, dcVoltageMax)); + break; + case Attributes::DcCurrent::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, dcCurrent)); + break; + case Attributes::DcCurrentMin::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, dcCurrentMin)); + break; + case Attributes::DcCurrentMax::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, dcCurrentMax)); + break; + case Attributes::DcPower::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, dcPower)); + break; + case Attributes::DcPowerMin::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, dcPowerMin)); + break; + case Attributes::DcPowerMax::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, dcPowerMax)); + break; + case Attributes::DcVoltageMultiplier::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, dcVoltageMultiplier)); + break; + case Attributes::DcVoltageDivisor::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, dcVoltageDivisor)); + break; + case Attributes::DcCurrentMultiplier::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, dcCurrentMultiplier)); + break; + case Attributes::DcCurrentDivisor::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, dcCurrentDivisor)); + break; + case Attributes::DcPowerMultiplier::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, dcPowerMultiplier)); + break; + case Attributes::DcPowerDivisor::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, dcPowerDivisor)); + break; + case Attributes::AcFrequency::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, acFrequency)); + break; + case Attributes::AcFrequencyMin::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, acFrequencyMin)); + break; + case Attributes::AcFrequencyMax::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, acFrequencyMax)); + break; + case Attributes::NeutralCurrent::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, neutralCurrent)); + break; + case Attributes::TotalActivePower::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, totalActivePower)); + break; + case Attributes::TotalReactivePower::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, totalReactivePower)); + break; + case Attributes::TotalApparentPower::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, totalApparentPower)); + break; + case Attributes::Measured1stHarmonicCurrent::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, measured1stHarmonicCurrent)); + break; + case Attributes::Measured3rdHarmonicCurrent::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, measured3rdHarmonicCurrent)); + break; + case Attributes::Measured5thHarmonicCurrent::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, measured5thHarmonicCurrent)); + break; + case Attributes::Measured7thHarmonicCurrent::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, measured7thHarmonicCurrent)); + break; + case Attributes::Measured9thHarmonicCurrent::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, measured9thHarmonicCurrent)); + break; + case Attributes::Measured11thHarmonicCurrent::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, measured11thHarmonicCurrent)); + break; + case Attributes::MeasuredPhase1stHarmonicCurrent::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredPhase1stHarmonicCurrent)); + break; + case Attributes::MeasuredPhase3rdHarmonicCurrent::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredPhase3rdHarmonicCurrent)); + break; + case Attributes::MeasuredPhase5thHarmonicCurrent::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredPhase5thHarmonicCurrent)); + break; + case Attributes::MeasuredPhase7thHarmonicCurrent::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredPhase7thHarmonicCurrent)); + break; + case Attributes::MeasuredPhase9thHarmonicCurrent::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredPhase9thHarmonicCurrent)); + break; + case Attributes::MeasuredPhase11thHarmonicCurrent::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, measuredPhase11thHarmonicCurrent)); + break; + case Attributes::AcFrequencyMultiplier::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, acFrequencyMultiplier)); + break; + case Attributes::AcFrequencyDivisor::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, acFrequencyDivisor)); + break; + case Attributes::PowerMultiplier::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, powerMultiplier)); + break; + case Attributes::PowerDivisor::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, powerDivisor)); + break; + case Attributes::HarmonicCurrentMultiplier::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, harmonicCurrentMultiplier)); + break; + case Attributes::PhaseHarmonicCurrentMultiplier::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, phaseHarmonicCurrentMultiplier)); + break; + case Attributes::InstantaneousVoltage::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, instantaneousVoltage)); + break; + case Attributes::InstantaneousLineCurrent::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, instantaneousLineCurrent)); + break; + case Attributes::InstantaneousActiveCurrent::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, instantaneousActiveCurrent)); + break; + case Attributes::InstantaneousReactiveCurrent::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, instantaneousReactiveCurrent)); + break; + case Attributes::InstantaneousPower::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, instantaneousPower)); + break; + case Attributes::RmsVoltage::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rmsVoltage)); + break; + case Attributes::RmsVoltageMin::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rmsVoltageMin)); + break; + case Attributes::RmsVoltageMax::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rmsVoltageMax)); + break; + case Attributes::RmsCurrent::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rmsCurrent)); + break; + case Attributes::RmsCurrentMin::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rmsCurrentMin)); + break; + case Attributes::RmsCurrentMax::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rmsCurrentMax)); + break; + case Attributes::ActivePower::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, activePower)); + break; + case Attributes::ActivePowerMin::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, activePowerMin)); + break; + case Attributes::ActivePowerMax::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, activePowerMax)); + break; + case Attributes::ReactivePower::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, reactivePower)); + break; + case Attributes::ApparentPower::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, apparentPower)); + break; + case Attributes::PowerFactor::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, powerFactor)); + break; + case Attributes::AverageRmsVoltageMeasurementPeriod::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, averageRmsVoltageMeasurementPeriod)); + break; + case Attributes::AverageRmsUnderVoltageCounter::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, averageRmsUnderVoltageCounter)); + break; + case Attributes::RmsExtremeOverVoltagePeriod::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rmsExtremeOverVoltagePeriod)); + break; + case Attributes::RmsExtremeUnderVoltagePeriod::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rmsExtremeUnderVoltagePeriod)); + break; + case Attributes::RmsVoltageSagPeriod::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rmsVoltageSagPeriod)); + break; + case Attributes::RmsVoltageSwellPeriod::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rmsVoltageSwellPeriod)); + break; + case Attributes::AcVoltageMultiplier::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, acVoltageMultiplier)); + break; + case Attributes::AcVoltageDivisor::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, acVoltageDivisor)); + break; + case Attributes::AcCurrentMultiplier::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, acCurrentMultiplier)); + break; + case Attributes::AcCurrentDivisor::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, acCurrentDivisor)); + break; + case Attributes::AcPowerMultiplier::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, acPowerMultiplier)); + break; + case Attributes::AcPowerDivisor::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, acPowerDivisor)); + break; + case Attributes::OverloadAlarmsMask::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, overloadAlarmsMask)); + break; + case Attributes::VoltageOverload::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, voltageOverload)); + break; + case Attributes::CurrentOverload::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, currentOverload)); + break; + case Attributes::AcOverloadAlarmsMask::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, acOverloadAlarmsMask)); + break; + case Attributes::AcVoltageOverload::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, acVoltageOverload)); + break; + case Attributes::AcCurrentOverload::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, acCurrentOverload)); + break; + case Attributes::AcActivePowerOverload::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, acActivePowerOverload)); + break; + case Attributes::AcReactivePowerOverload::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, acReactivePowerOverload)); + break; + case Attributes::AverageRmsOverVoltage::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, averageRmsOverVoltage)); + break; + case Attributes::AverageRmsUnderVoltage::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, averageRmsUnderVoltage)); + break; + case Attributes::RmsExtremeOverVoltage::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rmsExtremeOverVoltage)); + break; + case Attributes::RmsExtremeUnderVoltage::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rmsExtremeUnderVoltage)); + break; + case Attributes::RmsVoltageSag::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rmsVoltageSag)); + break; + case Attributes::RmsVoltageSwell::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rmsVoltageSwell)); + break; + case Attributes::LineCurrentPhaseB::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, lineCurrentPhaseB)); + break; + case Attributes::ActiveCurrentPhaseB::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, activeCurrentPhaseB)); + break; + case Attributes::ReactiveCurrentPhaseB::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, reactiveCurrentPhaseB)); + break; + case Attributes::RmsVoltagePhaseB::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rmsVoltagePhaseB)); + break; + case Attributes::RmsVoltageMinPhaseB::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rmsVoltageMinPhaseB)); + break; + case Attributes::RmsVoltageMaxPhaseB::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rmsVoltageMaxPhaseB)); + break; + case Attributes::RmsCurrentPhaseB::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rmsCurrentPhaseB)); + break; + case Attributes::RmsCurrentMinPhaseB::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rmsCurrentMinPhaseB)); + break; + case Attributes::RmsCurrentMaxPhaseB::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rmsCurrentMaxPhaseB)); + break; + case Attributes::ActivePowerPhaseB::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, activePowerPhaseB)); + break; + case Attributes::ActivePowerMinPhaseB::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, activePowerMinPhaseB)); + break; + case Attributes::ActivePowerMaxPhaseB::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, activePowerMaxPhaseB)); + break; + case Attributes::ReactivePowerPhaseB::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, reactivePowerPhaseB)); + break; + case Attributes::ApparentPowerPhaseB::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, apparentPowerPhaseB)); + break; + case Attributes::PowerFactorPhaseB::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, powerFactorPhaseB)); + break; + case Attributes::AverageRmsVoltageMeasurementPeriodPhaseB::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, averageRmsVoltageMeasurementPeriodPhaseB)); + break; + case Attributes::AverageRmsOverVoltageCounterPhaseB::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, averageRmsOverVoltageCounterPhaseB)); + break; + case Attributes::AverageRmsUnderVoltageCounterPhaseB::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, averageRmsUnderVoltageCounterPhaseB)); + break; + case Attributes::RmsExtremeOverVoltagePeriodPhaseB::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rmsExtremeOverVoltagePeriodPhaseB)); + break; + case Attributes::RmsExtremeUnderVoltagePeriodPhaseB::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rmsExtremeUnderVoltagePeriodPhaseB)); + break; + case Attributes::RmsVoltageSagPeriodPhaseB::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rmsVoltageSagPeriodPhaseB)); + break; + case Attributes::RmsVoltageSwellPeriodPhaseB::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rmsVoltageSwellPeriodPhaseB)); + break; + case Attributes::LineCurrentPhaseC::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, lineCurrentPhaseC)); + break; + case Attributes::ActiveCurrentPhaseC::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, activeCurrentPhaseC)); + break; + case Attributes::ReactiveCurrentPhaseC::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, reactiveCurrentPhaseC)); + break; + case Attributes::RmsVoltagePhaseC::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rmsVoltagePhaseC)); + break; + case Attributes::RmsVoltageMinPhaseC::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rmsVoltageMinPhaseC)); + break; + case Attributes::RmsVoltageMaxPhaseC::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rmsVoltageMaxPhaseC)); + break; + case Attributes::RmsCurrentPhaseC::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rmsCurrentPhaseC)); + break; + case Attributes::RmsCurrentMinPhaseC::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rmsCurrentMinPhaseC)); + break; + case Attributes::RmsCurrentMaxPhaseC::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rmsCurrentMaxPhaseC)); + break; + case Attributes::ActivePowerPhaseC::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, activePowerPhaseC)); + break; + case Attributes::ActivePowerMinPhaseC::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, activePowerMinPhaseC)); + break; + case Attributes::ActivePowerMaxPhaseC::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, activePowerMaxPhaseC)); + break; + case Attributes::ReactivePowerPhaseC::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, reactivePowerPhaseC)); + break; + case Attributes::ApparentPowerPhaseC::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, apparentPowerPhaseC)); + break; + case Attributes::PowerFactorPhaseC::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, powerFactorPhaseC)); + break; + case Attributes::AverageRmsVoltageMeasurementPeriodPhaseC::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, averageRmsVoltageMeasurementPeriodPhaseC)); + break; + case Attributes::AverageRmsOverVoltageCounterPhaseC::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, averageRmsOverVoltageCounterPhaseC)); + break; + case Attributes::AverageRmsUnderVoltageCounterPhaseC::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, averageRmsUnderVoltageCounterPhaseC)); + break; + case Attributes::RmsExtremeOverVoltagePeriodPhaseC::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rmsExtremeOverVoltagePeriodPhaseC)); + break; + case Attributes::RmsExtremeUnderVoltagePeriodPhaseC::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rmsExtremeUnderVoltagePeriodPhaseC)); + break; + case Attributes::RmsVoltageSagPeriodPhaseC::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rmsVoltageSagPeriodPhaseC)); + break; + case Attributes::RmsVoltageSwellPeriodPhaseC::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, rmsVoltageSwellPeriodPhaseC)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + namespace Events { } // namespace Events diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h index 791bb31edfde45..5bdd9efe2fbdc5 100644 --- a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h +++ b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h @@ -40,6 +40,7 @@ namespace Clusters { namespace PowerConfiguration { namespace Attributes { + namespace MainsVoltage { struct TypeInfo { @@ -760,11 +761,83 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::PowerConfiguration::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MainsVoltage::TypeInfo::DecodableType mainsVoltage; + Attributes::MainsFrequency::TypeInfo::DecodableType mainsFrequency; + Attributes::MainsAlarmMask::TypeInfo::DecodableType mainsAlarmMask; + Attributes::MainsVoltageMinThreshold::TypeInfo::DecodableType mainsVoltageMinThreshold; + Attributes::MainsVoltageMaxThreshold::TypeInfo::DecodableType mainsVoltageMaxThreshold; + Attributes::MainsVoltageDwellTrip::TypeInfo::DecodableType mainsVoltageDwellTrip; + Attributes::BatteryVoltage::TypeInfo::DecodableType batteryVoltage; + Attributes::BatteryPercentageRemaining::TypeInfo::DecodableType batteryPercentageRemaining; + Attributes::BatteryManufacturer::TypeInfo::DecodableType batteryManufacturer; + Attributes::BatterySize::TypeInfo::DecodableType batterySize; + Attributes::BatteryAhrRating::TypeInfo::DecodableType batteryAhrRating; + Attributes::BatteryQuantity::TypeInfo::DecodableType batteryQuantity; + Attributes::BatteryRatedVoltage::TypeInfo::DecodableType batteryRatedVoltage; + Attributes::BatteryAlarmMask::TypeInfo::DecodableType batteryAlarmMask; + Attributes::BatteryVoltageMinThreshold::TypeInfo::DecodableType batteryVoltageMinThreshold; + Attributes::BatteryVoltageThreshold1::TypeInfo::DecodableType batteryVoltageThreshold1; + Attributes::BatteryVoltageThreshold2::TypeInfo::DecodableType batteryVoltageThreshold2; + Attributes::BatteryVoltageThreshold3::TypeInfo::DecodableType batteryVoltageThreshold3; + Attributes::BatteryPercentageMinThreshold::TypeInfo::DecodableType batteryPercentageMinThreshold; + Attributes::BatteryPercentageThreshold1::TypeInfo::DecodableType batteryPercentageThreshold1; + Attributes::BatteryPercentageThreshold2::TypeInfo::DecodableType batteryPercentageThreshold2; + Attributes::BatteryPercentageThreshold3::TypeInfo::DecodableType batteryPercentageThreshold3; + Attributes::BatteryAlarmState::TypeInfo::DecodableType batteryAlarmState; + Attributes::Battery2Voltage::TypeInfo::DecodableType battery2Voltage; + Attributes::Battery2PercentageRemaining::TypeInfo::DecodableType battery2PercentageRemaining; + Attributes::Battery2Manufacturer::TypeInfo::DecodableType battery2Manufacturer; + Attributes::Battery2Size::TypeInfo::DecodableType battery2Size; + Attributes::Battery2AhrRating::TypeInfo::DecodableType battery2AhrRating; + Attributes::Battery2Quantity::TypeInfo::DecodableType battery2Quantity; + Attributes::Battery2RatedVoltage::TypeInfo::DecodableType battery2RatedVoltage; + Attributes::Battery2AlarmMask::TypeInfo::DecodableType battery2AlarmMask; + Attributes::Battery2VoltageMinThreshold::TypeInfo::DecodableType battery2VoltageMinThreshold; + Attributes::Battery2VoltageThreshold1::TypeInfo::DecodableType battery2VoltageThreshold1; + Attributes::Battery2VoltageThreshold2::TypeInfo::DecodableType battery2VoltageThreshold2; + Attributes::Battery2VoltageThreshold3::TypeInfo::DecodableType battery2VoltageThreshold3; + Attributes::Battery2PercentageMinThreshold::TypeInfo::DecodableType battery2PercentageMinThreshold; + Attributes::Battery2PercentageThreshold1::TypeInfo::DecodableType battery2PercentageThreshold1; + Attributes::Battery2PercentageThreshold2::TypeInfo::DecodableType battery2PercentageThreshold2; + Attributes::Battery2PercentageThreshold3::TypeInfo::DecodableType battery2PercentageThreshold3; + Attributes::Battery2AlarmState::TypeInfo::DecodableType battery2AlarmState; + Attributes::Battery3Voltage::TypeInfo::DecodableType battery3Voltage; + Attributes::Battery3PercentageRemaining::TypeInfo::DecodableType battery3PercentageRemaining; + Attributes::Battery3Manufacturer::TypeInfo::DecodableType battery3Manufacturer; + Attributes::Battery3Size::TypeInfo::DecodableType battery3Size; + Attributes::Battery3AhrRating::TypeInfo::DecodableType battery3AhrRating; + Attributes::Battery3Quantity::TypeInfo::DecodableType battery3Quantity; + Attributes::Battery3RatedVoltage::TypeInfo::DecodableType battery3RatedVoltage; + Attributes::Battery3AlarmMask::TypeInfo::DecodableType battery3AlarmMask; + Attributes::Battery3VoltageMinThreshold::TypeInfo::DecodableType battery3VoltageMinThreshold; + Attributes::Battery3VoltageThreshold1::TypeInfo::DecodableType battery3VoltageThreshold1; + Attributes::Battery3VoltageThreshold2::TypeInfo::DecodableType battery3VoltageThreshold2; + Attributes::Battery3VoltageThreshold3::TypeInfo::DecodableType battery3VoltageThreshold3; + Attributes::Battery3PercentageMinThreshold::TypeInfo::DecodableType battery3PercentageMinThreshold; + Attributes::Battery3PercentageThreshold1::TypeInfo::DecodableType battery3PercentageThreshold1; + Attributes::Battery3PercentageThreshold2::TypeInfo::DecodableType battery3PercentageThreshold2; + Attributes::Battery3PercentageThreshold3::TypeInfo::DecodableType battery3PercentageThreshold3; + Attributes::Battery3AlarmState::TypeInfo::DecodableType battery3AlarmState; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace PowerConfiguration namespace DeviceTemperatureConfiguration { namespace Attributes { + namespace CurrentTemperature { struct TypeInfo { @@ -909,6 +982,29 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::DeviceTemperatureConfiguration::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::CurrentTemperature::TypeInfo::DecodableType currentTemperature; + Attributes::MinTempExperienced::TypeInfo::DecodableType minTempExperienced; + Attributes::MaxTempExperienced::TypeInfo::DecodableType maxTempExperienced; + Attributes::OverTempTotalDwell::TypeInfo::DecodableType overTempTotalDwell; + Attributes::DeviceTempAlarmMask::TypeInfo::DecodableType deviceTempAlarmMask; + Attributes::LowTempThreshold::TypeInfo::DecodableType lowTempThreshold; + Attributes::HighTempThreshold::TypeInfo::DecodableType highTempThreshold; + Attributes::LowTempDwellTripPoint::TypeInfo::DecodableType lowTempDwellTripPoint; + Attributes::HighTempDwellTripPoint::TypeInfo::DecodableType highTempDwellTripPoint; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace DeviceTemperatureConfiguration namespace Identify { @@ -1112,6 +1208,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace IdentifyTime { struct TypeInfo { @@ -1172,6 +1269,22 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::Identify::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::IdentifyTime::TypeInfo::DecodableType identifyTime; + Attributes::IdentifyType::TypeInfo::DecodableType identifyType; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace Identify namespace Groups { @@ -1572,6 +1685,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace NameSupport { struct TypeInfo { @@ -1620,6 +1734,21 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::Groups::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::NameSupport::TypeInfo::DecodableType nameSupport; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace Groups namespace Scenes { @@ -2496,6 +2625,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace SceneCount { struct TypeInfo { @@ -2604,6 +2734,26 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::Scenes::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::SceneCount::TypeInfo::DecodableType sceneCount; + Attributes::CurrentScene::TypeInfo::DecodableType currentScene; + Attributes::CurrentGroup::TypeInfo::DecodableType currentGroup; + Attributes::SceneValid::TypeInfo::DecodableType sceneValid; + Attributes::NameSupport::TypeInfo::DecodableType nameSupport; + Attributes::LastConfiguredBy::TypeInfo::DecodableType lastConfiguredBy; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace Scenes namespace OnOff { @@ -2874,6 +3024,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace OnOff { struct TypeInfo { @@ -2970,11 +3121,31 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::OnOff::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::OnOff::TypeInfo::DecodableType onOff; + Attributes::GlobalSceneControl::TypeInfo::DecodableType globalSceneControl; + Attributes::OnTime::TypeInfo::DecodableType onTime; + Attributes::OffWaitTime::TypeInfo::DecodableType offWaitTime; + Attributes::StartUpOnOff::TypeInfo::DecodableType startUpOnOff; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace OnOff namespace OnOffSwitchConfiguration { namespace Attributes { + namespace SwitchType { struct TypeInfo { @@ -3035,6 +3206,22 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::OnOffSwitchConfiguration::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::SwitchType::TypeInfo::DecodableType switchType; + Attributes::SwitchActions::TypeInfo::DecodableType switchActions; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace OnOffSwitchConfiguration namespace LevelControl { @@ -3409,6 +3596,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace CurrentLevel { struct TypeInfo { @@ -3613,6 +3801,34 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::LevelControl::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::CurrentLevel::TypeInfo::DecodableType currentLevel; + Attributes::RemainingTime::TypeInfo::DecodableType remainingTime; + Attributes::MinLevel::TypeInfo::DecodableType minLevel; + Attributes::MaxLevel::TypeInfo::DecodableType maxLevel; + Attributes::CurrentFrequency::TypeInfo::DecodableType currentFrequency; + Attributes::MinFrequency::TypeInfo::DecodableType minFrequency; + Attributes::MaxFrequency::TypeInfo::DecodableType maxFrequency; + Attributes::Options::TypeInfo::DecodableType options; + Attributes::OnOffTransitionTime::TypeInfo::DecodableType onOffTransitionTime; + Attributes::OnLevel::TypeInfo::DecodableType onLevel; + Attributes::OnTransitionTime::TypeInfo::DecodableType onTransitionTime; + Attributes::OffTransitionTime::TypeInfo::DecodableType offTransitionTime; + Attributes::DefaultMoveRate::TypeInfo::DecodableType defaultMoveRate; + Attributes::StartUpCurrentLevel::TypeInfo::DecodableType startUpCurrentLevel; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace LevelControl namespace Alarms { @@ -3851,6 +4067,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace AlarmCount { struct TypeInfo { @@ -3899,11 +4116,27 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::Alarms::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::AlarmCount::TypeInfo::DecodableType alarmCount; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace Alarms namespace Time { namespace Attributes { + namespace Time { struct TypeInfo { @@ -4060,11 +4293,36 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::Time::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::Time::TypeInfo::DecodableType time; + Attributes::TimeStatus::TypeInfo::DecodableType timeStatus; + Attributes::TimeZone::TypeInfo::DecodableType timeZone; + Attributes::DstStart::TypeInfo::DecodableType dstStart; + Attributes::DstEnd::TypeInfo::DecodableType dstEnd; + Attributes::DstShift::TypeInfo::DecodableType dstShift; + Attributes::StandardTime::TypeInfo::DecodableType standardTime; + Attributes::LocalTime::TypeInfo::DecodableType localTime; + Attributes::LastSetTime::TypeInfo::DecodableType lastSetTime; + Attributes::ValidUntilTime::TypeInfo::DecodableType validUntilTime; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace Time namespace BinaryInputBasic { namespace Attributes { + namespace ActiveText { struct TypeInfo { @@ -4209,6 +4467,29 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::BinaryInputBasic::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::ActiveText::TypeInfo::DecodableType activeText; + Attributes::Description::TypeInfo::DecodableType description; + Attributes::InactiveText::TypeInfo::DecodableType inactiveText; + Attributes::OutOfService::TypeInfo::DecodableType outOfService; + Attributes::Polarity::TypeInfo::DecodableType polarity; + Attributes::PresentValue::TypeInfo::DecodableType presentValue; + Attributes::Reliability::TypeInfo::DecodableType reliability; + Attributes::StatusFlags::TypeInfo::DecodableType statusFlags; + Attributes::ApplicationType::TypeInfo::DecodableType applicationType; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace BinaryInputBasic namespace PowerProfile { @@ -5156,6 +5437,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace TotalProfileNum { struct TypeInfo { @@ -5252,6 +5534,25 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::PowerProfile::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::TotalProfileNum::TypeInfo::DecodableType totalProfileNum; + Attributes::MultipleScheduling::TypeInfo::DecodableType multipleScheduling; + Attributes::EnergyFormatting::TypeInfo::DecodableType energyFormatting; + Attributes::EnergyRemote::TypeInfo::DecodableType energyRemote; + Attributes::ScheduleMode::TypeInfo::DecodableType scheduleMode; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace PowerProfile namespace ApplianceControl { @@ -5617,6 +5918,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace StartTime { struct TypeInfo { @@ -5689,11 +5991,29 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::ApplianceControl::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::StartTime::TypeInfo::DecodableType startTime; + Attributes::FinishTime::TypeInfo::DecodableType finishTime; + Attributes::RemainingTime::TypeInfo::DecodableType remainingTime; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace ApplianceControl namespace PulseWidthModulation { namespace Attributes { + namespace AttributeList { struct TypeInfo { @@ -5730,6 +6050,20 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::PulseWidthModulation::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace PulseWidthModulation namespace Descriptor { @@ -5758,6 +6092,7 @@ using DecodableType = Type; } // namespace Structs namespace Attributes { + namespace DeviceList { struct TypeInfo { @@ -5842,6 +6177,24 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::Descriptor::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::DeviceList::TypeInfo::DecodableType deviceList; + Attributes::ServerList::TypeInfo::DecodableType serverList; + Attributes::ClientList::TypeInfo::DecodableType clientList; + Attributes::PartsList::TypeInfo::DecodableType partsList; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace Descriptor namespace Binding { @@ -5947,6 +6300,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace AttributeList { struct TypeInfo { @@ -5983,6 +6337,20 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::Binding::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace Binding namespace AccessControl { @@ -6085,6 +6453,7 @@ using DecodableType = Type; } // namespace Structs namespace Attributes { + namespace Acl { struct TypeInfo { @@ -6145,6 +6514,22 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::AccessControl::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::Acl::TypeInfo::DecodableType acl; + Attributes::Extension::TypeInfo::DecodableType extension; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace AccessControl namespace PollControl { @@ -6338,6 +6723,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace CheckInInterval { struct TypeInfo { @@ -6458,6 +6844,27 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::PollControl::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::CheckInInterval::TypeInfo::DecodableType checkInInterval; + Attributes::LongPollInterval::TypeInfo::DecodableType longPollInterval; + Attributes::ShortPollInterval::TypeInfo::DecodableType shortPollInterval; + Attributes::FastPollTimeout::TypeInfo::DecodableType fastPollTimeout; + Attributes::CheckInIntervalMin::TypeInfo::DecodableType checkInIntervalMin; + Attributes::LongPollIntervalMin::TypeInfo::DecodableType longPollIntervalMin; + Attributes::FastPollTimeoutMax::TypeInfo::DecodableType fastPollTimeoutMax; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace PollControl namespace BridgedActions { @@ -7077,6 +7484,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace ActionList { struct TypeInfo { @@ -7149,6 +7557,23 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::BridgedActions::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::ActionList::TypeInfo::DecodableType actionList; + Attributes::EndpointList::TypeInfo::DecodableType endpointList; + Attributes::SetupUrl::TypeInfo::DecodableType setupUrl; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes namespace Events { namespace StateChanged { @@ -7278,6 +7703,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace InteractionModelVersion { struct TypeInfo { @@ -7542,6 +7968,39 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::Basic::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::InteractionModelVersion::TypeInfo::DecodableType interactionModelVersion; + Attributes::VendorName::TypeInfo::DecodableType vendorName; + Attributes::VendorID::TypeInfo::DecodableType vendorID; + Attributes::ProductName::TypeInfo::DecodableType productName; + Attributes::ProductID::TypeInfo::DecodableType productID; + Attributes::NodeLabel::TypeInfo::DecodableType nodeLabel; + Attributes::Location::TypeInfo::DecodableType location; + Attributes::HardwareVersion::TypeInfo::DecodableType hardwareVersion; + Attributes::HardwareVersionString::TypeInfo::DecodableType hardwareVersionString; + Attributes::SoftwareVersion::TypeInfo::DecodableType softwareVersion; + Attributes::SoftwareVersionString::TypeInfo::DecodableType softwareVersionString; + Attributes::ManufacturingDate::TypeInfo::DecodableType manufacturingDate; + Attributes::PartNumber::TypeInfo::DecodableType partNumber; + Attributes::ProductURL::TypeInfo::DecodableType productURL; + Attributes::ProductLabel::TypeInfo::DecodableType productLabel; + Attributes::SerialNumber::TypeInfo::DecodableType serialNumber; + Attributes::LocalConfigDisabled::TypeInfo::DecodableType localConfigDisabled; + Attributes::Reachable::TypeInfo::DecodableType reachable; + Attributes::UniqueID::TypeInfo::DecodableType uniqueID; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes namespace Events { namespace StartUp { @@ -7950,6 +8409,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace AttributeList { struct TypeInfo { @@ -7986,6 +8446,20 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateProvider::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace OtaSoftwareUpdateProvider namespace OtaSoftwareUpdateRequestor { @@ -8092,6 +8566,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace DefaultOtaProvider { struct TypeInfo { @@ -8152,6 +8627,22 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::OtaSoftwareUpdateRequestor::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::DefaultOtaProvider::TypeInfo::DecodableType defaultOtaProvider; + Attributes::UpdatePossible::TypeInfo::DecodableType updatePossible; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes namespace Events { namespace StateTransition { @@ -8279,6 +8770,7 @@ struct DecodableType namespace LocalizationConfiguration { namespace Attributes { + namespace AttributeList { struct TypeInfo { @@ -8315,11 +8807,26 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::LocalizationConfiguration::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace LocalizationConfiguration namespace LocalizationTimeFormat { namespace Attributes { + namespace AttributeList { struct TypeInfo { @@ -8356,11 +8863,26 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::LocalizationTimeFormat::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace LocalizationTimeFormat namespace LocalizationUnit { namespace Attributes { + namespace AttributeList { struct TypeInfo { @@ -8397,11 +8919,26 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::LocalizationUnit::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace LocalizationUnit namespace PowerSourceConfiguration { namespace Attributes { + namespace Sources { struct TypeInfo { @@ -8450,6 +8987,21 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::PowerSourceConfiguration::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::Sources::TypeInfo::DecodableType sources; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace PowerSourceConfiguration namespace PowerSource { @@ -8464,6 +9016,7 @@ enum class PowerSourceFeature : uint32_t }; namespace Attributes { + namespace Status { struct TypeInfo { @@ -8872,6 +9425,51 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::PowerSource::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::Status::TypeInfo::DecodableType status; + Attributes::Order::TypeInfo::DecodableType order; + Attributes::Description::TypeInfo::DecodableType description; + Attributes::WiredAssessedInputVoltage::TypeInfo::DecodableType wiredAssessedInputVoltage; + Attributes::WiredAssessedInputFrequency::TypeInfo::DecodableType wiredAssessedInputFrequency; + Attributes::WiredCurrentType::TypeInfo::DecodableType wiredCurrentType; + Attributes::WiredAssessedCurrent::TypeInfo::DecodableType wiredAssessedCurrent; + Attributes::WiredNominalVoltage::TypeInfo::DecodableType wiredNominalVoltage; + Attributes::WiredMaximumCurrent::TypeInfo::DecodableType wiredMaximumCurrent; + Attributes::WiredPresent::TypeInfo::DecodableType wiredPresent; + Attributes::ActiveWiredFaults::TypeInfo::DecodableType activeWiredFaults; + Attributes::BatteryVoltage::TypeInfo::DecodableType batteryVoltage; + Attributes::BatteryPercentRemaining::TypeInfo::DecodableType batteryPercentRemaining; + Attributes::BatteryTimeRemaining::TypeInfo::DecodableType batteryTimeRemaining; + Attributes::BatteryChargeLevel::TypeInfo::DecodableType batteryChargeLevel; + Attributes::BatteryReplacementNeeded::TypeInfo::DecodableType batteryReplacementNeeded; + Attributes::BatteryReplaceability::TypeInfo::DecodableType batteryReplaceability; + Attributes::BatteryPresent::TypeInfo::DecodableType batteryPresent; + Attributes::ActiveBatteryFaults::TypeInfo::DecodableType activeBatteryFaults; + Attributes::BatteryReplacementDescription::TypeInfo::DecodableType batteryReplacementDescription; + Attributes::BatteryCommonDesignation::TypeInfo::DecodableType batteryCommonDesignation; + Attributes::BatteryANSIDesignation::TypeInfo::DecodableType batteryANSIDesignation; + Attributes::BatteryIECDesignation::TypeInfo::DecodableType batteryIECDesignation; + Attributes::BatteryApprovedChemistry::TypeInfo::DecodableType batteryApprovedChemistry; + Attributes::BatteryCapacity::TypeInfo::DecodableType batteryCapacity; + Attributes::BatteryQuantity::TypeInfo::DecodableType batteryQuantity; + Attributes::BatteryChargeState::TypeInfo::DecodableType batteryChargeState; + Attributes::BatteryTimeToFullCharge::TypeInfo::DecodableType batteryTimeToFullCharge; + Attributes::BatteryFunctionalWhileCharging::TypeInfo::DecodableType batteryFunctionalWhileCharging; + Attributes::BatteryChargingCurrent::TypeInfo::DecodableType batteryChargingCurrent; + Attributes::ActiveBatteryChargeFaults::TypeInfo::DecodableType activeBatteryChargeFaults; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace PowerSource namespace GeneralCommissioning { @@ -9169,6 +9767,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace Breadcrumb { struct TypeInfo { @@ -9253,6 +9852,24 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::GeneralCommissioning::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::Breadcrumb::TypeInfo::DecodableType breadcrumb; + Attributes::BasicCommissioningInfoList::TypeInfo::DecodableType basicCommissioningInfoList; + Attributes::RegulatoryConfig::TypeInfo::DecodableType regulatoryConfig; + Attributes::LocationCapability::TypeInfo::DecodableType locationCapability; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace GeneralCommissioning namespace NetworkCommissioning { @@ -9741,6 +10358,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace MaxNetworks { struct TypeInfo { @@ -9873,6 +10491,28 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::NetworkCommissioning::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MaxNetworks::TypeInfo::DecodableType maxNetworks; + Attributes::Networks::TypeInfo::DecodableType networks; + Attributes::ScanMaxTimeSeconds::TypeInfo::DecodableType scanMaxTimeSeconds; + Attributes::ConnectMaxTimeSeconds::TypeInfo::DecodableType connectMaxTimeSeconds; + Attributes::InterfaceEnabled::TypeInfo::DecodableType interfaceEnabled; + Attributes::LastNetworkingStatus::TypeInfo::DecodableType lastNetworkingStatus; + Attributes::LastNetworkID::TypeInfo::DecodableType lastNetworkID; + Attributes::LastConnectErrorValue::TypeInfo::DecodableType lastConnectErrorValue; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace NetworkCommissioning namespace DiagnosticLogs { @@ -9997,6 +10637,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace AttributeList { struct TypeInfo { @@ -10033,6 +10674,20 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::DiagnosticLogs::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace DiagnosticLogs namespace GeneralDiagnostics { @@ -10153,6 +10808,7 @@ using DecodableType = Type; } // namespace Structs namespace Attributes { + namespace NetworkInterfaces { struct TypeInfo { @@ -10285,6 +10941,28 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::GeneralDiagnostics::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::NetworkInterfaces::TypeInfo::DecodableType networkInterfaces; + Attributes::RebootCount::TypeInfo::DecodableType rebootCount; + Attributes::UpTime::TypeInfo::DecodableType upTime; + Attributes::TotalOperationalHours::TypeInfo::DecodableType totalOperationalHours; + Attributes::BootReasons::TypeInfo::DecodableType bootReasons; + Attributes::ActiveHardwareFaults::TypeInfo::DecodableType activeHardwareFaults; + Attributes::ActiveRadioFaults::TypeInfo::DecodableType activeRadioFaults; + Attributes::ActiveNetworkFaults::TypeInfo::DecodableType activeNetworkFaults; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes namespace Events { namespace HardwareFaultChange { @@ -10525,6 +11203,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace ThreadMetrics { struct TypeInfo { @@ -10609,6 +11288,24 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::SoftwareDiagnostics::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::ThreadMetrics::TypeInfo::DecodableType threadMetrics; + Attributes::CurrentHeapFree::TypeInfo::DecodableType currentHeapFree; + Attributes::CurrentHeapUsed::TypeInfo::DecodableType currentHeapUsed; + Attributes::CurrentHeapHighWatermark::TypeInfo::DecodableType currentHeapHighWatermark; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes namespace Events { namespace SoftwareFault { @@ -10864,6 +11561,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace Channel { struct TypeInfo { @@ -11656,6 +12354,83 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::ThreadNetworkDiagnostics::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::Channel::TypeInfo::DecodableType channel; + Attributes::RoutingRole::TypeInfo::DecodableType routingRole; + Attributes::NetworkName::TypeInfo::DecodableType networkName; + Attributes::PanId::TypeInfo::DecodableType panId; + Attributes::ExtendedPanId::TypeInfo::DecodableType extendedPanId; + Attributes::MeshLocalPrefix::TypeInfo::DecodableType meshLocalPrefix; + Attributes::OverrunCount::TypeInfo::DecodableType overrunCount; + Attributes::NeighborTableList::TypeInfo::DecodableType neighborTableList; + Attributes::RouteTableList::TypeInfo::DecodableType routeTableList; + Attributes::PartitionId::TypeInfo::DecodableType partitionId; + Attributes::Weighting::TypeInfo::DecodableType weighting; + Attributes::DataVersion::TypeInfo::DecodableType dataVersion; + Attributes::StableDataVersion::TypeInfo::DecodableType stableDataVersion; + Attributes::LeaderRouterId::TypeInfo::DecodableType leaderRouterId; + Attributes::DetachedRoleCount::TypeInfo::DecodableType detachedRoleCount; + Attributes::ChildRoleCount::TypeInfo::DecodableType childRoleCount; + Attributes::RouterRoleCount::TypeInfo::DecodableType routerRoleCount; + Attributes::LeaderRoleCount::TypeInfo::DecodableType leaderRoleCount; + Attributes::AttachAttemptCount::TypeInfo::DecodableType attachAttemptCount; + Attributes::PartitionIdChangeCount::TypeInfo::DecodableType partitionIdChangeCount; + Attributes::BetterPartitionAttachAttemptCount::TypeInfo::DecodableType betterPartitionAttachAttemptCount; + Attributes::ParentChangeCount::TypeInfo::DecodableType parentChangeCount; + Attributes::TxTotalCount::TypeInfo::DecodableType txTotalCount; + Attributes::TxUnicastCount::TypeInfo::DecodableType txUnicastCount; + Attributes::TxBroadcastCount::TypeInfo::DecodableType txBroadcastCount; + Attributes::TxAckRequestedCount::TypeInfo::DecodableType txAckRequestedCount; + Attributes::TxAckedCount::TypeInfo::DecodableType txAckedCount; + Attributes::TxNoAckRequestedCount::TypeInfo::DecodableType txNoAckRequestedCount; + Attributes::TxDataCount::TypeInfo::DecodableType txDataCount; + Attributes::TxDataPollCount::TypeInfo::DecodableType txDataPollCount; + Attributes::TxBeaconCount::TypeInfo::DecodableType txBeaconCount; + Attributes::TxBeaconRequestCount::TypeInfo::DecodableType txBeaconRequestCount; + Attributes::TxOtherCount::TypeInfo::DecodableType txOtherCount; + Attributes::TxRetryCount::TypeInfo::DecodableType txRetryCount; + Attributes::TxDirectMaxRetryExpiryCount::TypeInfo::DecodableType txDirectMaxRetryExpiryCount; + Attributes::TxIndirectMaxRetryExpiryCount::TypeInfo::DecodableType txIndirectMaxRetryExpiryCount; + Attributes::TxErrCcaCount::TypeInfo::DecodableType txErrCcaCount; + Attributes::TxErrAbortCount::TypeInfo::DecodableType txErrAbortCount; + Attributes::TxErrBusyChannelCount::TypeInfo::DecodableType txErrBusyChannelCount; + Attributes::RxTotalCount::TypeInfo::DecodableType rxTotalCount; + Attributes::RxUnicastCount::TypeInfo::DecodableType rxUnicastCount; + Attributes::RxBroadcastCount::TypeInfo::DecodableType rxBroadcastCount; + Attributes::RxDataCount::TypeInfo::DecodableType rxDataCount; + Attributes::RxDataPollCount::TypeInfo::DecodableType rxDataPollCount; + Attributes::RxBeaconCount::TypeInfo::DecodableType rxBeaconCount; + Attributes::RxBeaconRequestCount::TypeInfo::DecodableType rxBeaconRequestCount; + Attributes::RxOtherCount::TypeInfo::DecodableType rxOtherCount; + Attributes::RxAddressFilteredCount::TypeInfo::DecodableType rxAddressFilteredCount; + Attributes::RxDestAddrFilteredCount::TypeInfo::DecodableType rxDestAddrFilteredCount; + Attributes::RxDuplicatedCount::TypeInfo::DecodableType rxDuplicatedCount; + Attributes::RxErrNoFrameCount::TypeInfo::DecodableType rxErrNoFrameCount; + Attributes::RxErrUnknownNeighborCount::TypeInfo::DecodableType rxErrUnknownNeighborCount; + Attributes::RxErrInvalidSrcAddrCount::TypeInfo::DecodableType rxErrInvalidSrcAddrCount; + Attributes::RxErrSecCount::TypeInfo::DecodableType rxErrSecCount; + Attributes::RxErrFcsCount::TypeInfo::DecodableType rxErrFcsCount; + Attributes::RxErrOtherCount::TypeInfo::DecodableType rxErrOtherCount; + Attributes::ActiveTimestamp::TypeInfo::DecodableType activeTimestamp; + Attributes::PendingTimestamp::TypeInfo::DecodableType pendingTimestamp; + Attributes::Delay::TypeInfo::DecodableType delay; + Attributes::SecurityPolicy::TypeInfo::DecodableType securityPolicy; + Attributes::ChannelMask::TypeInfo::DecodableType channelMask; + Attributes::OperationalDatasetComponents::TypeInfo::DecodableType operationalDatasetComponents; + Attributes::ActiveNetworkFaultsList::TypeInfo::DecodableType activeNetworkFaultsList; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes namespace Events { namespace ConnectionStatus { @@ -11783,6 +12558,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace Bssid { struct TypeInfo { @@ -11975,6 +12751,33 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::WiFiNetworkDiagnostics::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::Bssid::TypeInfo::DecodableType bssid; + Attributes::SecurityType::TypeInfo::DecodableType securityType; + Attributes::WiFiVersion::TypeInfo::DecodableType wiFiVersion; + Attributes::ChannelNumber::TypeInfo::DecodableType channelNumber; + Attributes::Rssi::TypeInfo::DecodableType rssi; + Attributes::BeaconLostCount::TypeInfo::DecodableType beaconLostCount; + Attributes::BeaconRxCount::TypeInfo::DecodableType beaconRxCount; + Attributes::PacketMulticastRxCount::TypeInfo::DecodableType packetMulticastRxCount; + Attributes::PacketMulticastTxCount::TypeInfo::DecodableType packetMulticastTxCount; + Attributes::PacketUnicastRxCount::TypeInfo::DecodableType packetUnicastRxCount; + Attributes::PacketUnicastTxCount::TypeInfo::DecodableType packetUnicastTxCount; + Attributes::CurrentMaxRate::TypeInfo::DecodableType currentMaxRate; + Attributes::OverrunCount::TypeInfo::DecodableType overrunCount; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes namespace Events { namespace Disconnection { @@ -12145,6 +12948,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace PHYRate { struct TypeInfo { @@ -12289,11 +13093,35 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::EthernetNetworkDiagnostics::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::PHYRate::TypeInfo::DecodableType PHYRate; + Attributes::FullDuplex::TypeInfo::DecodableType fullDuplex; + Attributes::PacketRxCount::TypeInfo::DecodableType packetRxCount; + Attributes::PacketTxCount::TypeInfo::DecodableType packetTxCount; + Attributes::TxErrCount::TypeInfo::DecodableType txErrCount; + Attributes::CollisionCount::TypeInfo::DecodableType collisionCount; + Attributes::OverrunCount::TypeInfo::DecodableType overrunCount; + Attributes::CarrierDetect::TypeInfo::DecodableType carrierDetect; + Attributes::TimeSinceReset::TypeInfo::DecodableType timeSinceReset; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace EthernetNetworkDiagnostics namespace TimeSynchronization { namespace Attributes { + namespace AttributeList { struct TypeInfo { @@ -12330,6 +13158,20 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::TimeSynchronization::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace TimeSynchronization namespace BridgedDeviceBasic { @@ -12475,6 +13317,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace VendorName { struct TypeInfo { @@ -12691,11 +13534,41 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::BridgedDeviceBasic::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::VendorName::TypeInfo::DecodableType vendorName; + Attributes::VendorID::TypeInfo::DecodableType vendorID; + Attributes::ProductName::TypeInfo::DecodableType productName; + Attributes::NodeLabel::TypeInfo::DecodableType nodeLabel; + Attributes::HardwareVersion::TypeInfo::DecodableType hardwareVersion; + Attributes::HardwareVersionString::TypeInfo::DecodableType hardwareVersionString; + Attributes::SoftwareVersion::TypeInfo::DecodableType softwareVersion; + Attributes::SoftwareVersionString::TypeInfo::DecodableType softwareVersionString; + Attributes::ManufacturingDate::TypeInfo::DecodableType manufacturingDate; + Attributes::PartNumber::TypeInfo::DecodableType partNumber; + Attributes::ProductURL::TypeInfo::DecodableType productURL; + Attributes::ProductLabel::TypeInfo::DecodableType productLabel; + Attributes::SerialNumber::TypeInfo::DecodableType serialNumber; + Attributes::Reachable::TypeInfo::DecodableType reachable; + Attributes::UniqueID::TypeInfo::DecodableType uniqueID; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace BridgedDeviceBasic namespace Switch { namespace Attributes { + namespace NumberOfPositions { struct TypeInfo { @@ -12768,6 +13641,23 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::Switch::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::NumberOfPositions::TypeInfo::DecodableType numberOfPositions; + Attributes::CurrentPosition::TypeInfo::DecodableType currentPosition; + Attributes::MultiPressMax::TypeInfo::DecodableType multiPressMax; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes namespace Events { namespace SwitchLatched { @@ -13162,6 +14052,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace WindowStatus { struct TypeInfo { @@ -13234,6 +14125,23 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::AdministratorCommissioning::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::WindowStatus::TypeInfo::DecodableType windowStatus; + Attributes::AdminFabricIndex::TypeInfo::DecodableType adminFabricIndex; + Attributes::AdminVendorId::TypeInfo::DecodableType adminVendorId; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace AdministratorCommissioning namespace OperationalCredentials { @@ -13826,6 +14734,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace FabricsList { struct TypeInfo { @@ -13922,6 +14831,25 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::OperationalCredentials::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::FabricsList::TypeInfo::DecodableType fabricsList; + Attributes::SupportedFabrics::TypeInfo::DecodableType supportedFabrics; + Attributes::CommissionedFabrics::TypeInfo::DecodableType commissionedFabrics; + Attributes::TrustedRootCertificates::TypeInfo::DecodableType trustedRootCertificates; + Attributes::CurrentFabricIndex::TypeInfo::DecodableType currentFabricIndex; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace OperationalCredentials namespace GroupKeyManagement { @@ -13984,6 +14912,7 @@ using DecodableType = Type; } // namespace Structs namespace Attributes { + namespace Groups { struct TypeInfo { @@ -14044,6 +14973,22 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::GroupKeyManagement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::Groups::TypeInfo::DecodableType groups; + Attributes::GroupKeys::TypeInfo::DecodableType groupKeys; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace GroupKeyManagement namespace FixedLabel { @@ -14072,6 +15017,7 @@ using DecodableType = Type; } // namespace Structs namespace Attributes { + namespace LabelList { struct TypeInfo { @@ -14120,6 +15066,21 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::FixedLabel::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::LabelList::TypeInfo::DecodableType labelList; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace FixedLabel namespace UserLabel { @@ -14148,6 +15109,7 @@ using DecodableType = Type; } // namespace Structs namespace Attributes { + namespace LabelList { struct TypeInfo { @@ -14196,11 +15158,27 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::UserLabel::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::LabelList::TypeInfo::DecodableType labelList; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace UserLabel namespace ProxyConfiguration { namespace Attributes { + namespace AttributeList { struct TypeInfo { @@ -14237,11 +15215,26 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::ProxyConfiguration::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace ProxyConfiguration namespace ProxyDiscovery { namespace Attributes { + namespace AttributeList { struct TypeInfo { @@ -14278,11 +15271,26 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::ProxyDiscovery::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace ProxyDiscovery namespace ProxyValid { namespace Attributes { + namespace AttributeList { struct TypeInfo { @@ -14319,11 +15327,26 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::ProxyValid::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace ProxyValid namespace BooleanState { namespace Attributes { + namespace StateValue { struct TypeInfo { @@ -14372,6 +15395,21 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::BooleanState::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::StateValue::TypeInfo::DecodableType stateValue; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes namespace Events { namespace StateChange { @@ -14502,6 +15540,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace CurrentMode { struct TypeInfo { @@ -14598,11 +15637,31 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::ModeSelect::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::CurrentMode::TypeInfo::DecodableType currentMode; + Attributes::SupportedModes::TypeInfo::DecodableType supportedModes; + Attributes::OnMode::TypeInfo::DecodableType onMode; + Attributes::StartUpMode::TypeInfo::DecodableType startUpMode; + Attributes::Description::TypeInfo::DecodableType description; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace ModeSelect namespace ShadeConfiguration { namespace Attributes { + namespace PhysicalClosedLimit { struct TypeInfo { @@ -14699,6 +15758,25 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::ShadeConfiguration::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::PhysicalClosedLimit::TypeInfo::DecodableType physicalClosedLimit; + Attributes::MotorStepSize::TypeInfo::DecodableType motorStepSize; + Attributes::Status::TypeInfo::DecodableType status; + Attributes::ClosedLimit::TypeInfo::DecodableType closedLimit; + Attributes::Mode::TypeInfo::DecodableType mode; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace ShadeConfiguration namespace DoorLock { @@ -17017,6 +18095,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace LockState { struct TypeInfo { @@ -17593,6 +18672,65 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::DoorLock::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::LockState::TypeInfo::DecodableType lockState; + Attributes::LockType::TypeInfo::DecodableType lockType; + Attributes::ActuatorEnabled::TypeInfo::DecodableType actuatorEnabled; + Attributes::DoorState::TypeInfo::DecodableType doorState; + Attributes::DoorOpenEvents::TypeInfo::DecodableType doorOpenEvents; + Attributes::DoorClosedEvents::TypeInfo::DecodableType doorClosedEvents; + Attributes::OpenPeriod::TypeInfo::DecodableType openPeriod; + Attributes::NumberOfLogRecordsSupported::TypeInfo::DecodableType numberOfLogRecordsSupported; + Attributes::NumberOfTotalUsersSupported::TypeInfo::DecodableType numberOfTotalUsersSupported; + Attributes::NumberOfPINUsersSupported::TypeInfo::DecodableType numberOfPINUsersSupported; + Attributes::NumberOfRFIDUsersSupported::TypeInfo::DecodableType numberOfRFIDUsersSupported; + Attributes::NumberOfWeekDaySchedulesSupportedPerUser::TypeInfo::DecodableType numberOfWeekDaySchedulesSupportedPerUser; + Attributes::NumberOfYearDaySchedulesSupportedPerUser::TypeInfo::DecodableType numberOfYearDaySchedulesSupportedPerUser; + Attributes::NumberOfHolidaySchedulesSupported::TypeInfo::DecodableType numberOfHolidaySchedulesSupported; + Attributes::MaxPINCodeLength::TypeInfo::DecodableType maxPINCodeLength; + Attributes::MinPINCodeLength::TypeInfo::DecodableType minPINCodeLength; + Attributes::MaxRFIDCodeLength::TypeInfo::DecodableType maxRFIDCodeLength; + Attributes::MinRFIDCodeLength::TypeInfo::DecodableType minRFIDCodeLength; + Attributes::CredentialRulesSupport::TypeInfo::DecodableType credentialRulesSupport; + Attributes::EnableLogging::TypeInfo::DecodableType enableLogging; + Attributes::Language::TypeInfo::DecodableType language; + Attributes::LEDSettings::TypeInfo::DecodableType LEDSettings; + Attributes::AutoRelockTime::TypeInfo::DecodableType autoRelockTime; + Attributes::SoundVolume::TypeInfo::DecodableType soundVolume; + Attributes::OperatingMode::TypeInfo::DecodableType operatingMode; + Attributes::SupportedOperatingModes::TypeInfo::DecodableType supportedOperatingModes; + Attributes::DefaultConfigurationRegister::TypeInfo::DecodableType defaultConfigurationRegister; + Attributes::EnableLocalProgramming::TypeInfo::DecodableType enableLocalProgramming; + Attributes::EnableOneTouchLocking::TypeInfo::DecodableType enableOneTouchLocking; + Attributes::EnableInsideStatusLED::TypeInfo::DecodableType enableInsideStatusLED; + Attributes::EnablePrivacyModeButton::TypeInfo::DecodableType enablePrivacyModeButton; + Attributes::LocalProgrammingFeatures::TypeInfo::DecodableType localProgrammingFeatures; + Attributes::WrongCodeEntryLimit::TypeInfo::DecodableType wrongCodeEntryLimit; + Attributes::UserCodeTemporaryDisableTime::TypeInfo::DecodableType userCodeTemporaryDisableTime; + Attributes::SendPINOverTheAir::TypeInfo::DecodableType sendPINOverTheAir; + Attributes::RequirePINforRemoteOperation::TypeInfo::DecodableType requirePINforRemoteOperation; + Attributes::ExpiringUserTimeout::TypeInfo::DecodableType expiringUserTimeout; + Attributes::AlarmMask::TypeInfo::DecodableType alarmMask; + Attributes::KeypadOperationEventMask::TypeInfo::DecodableType keypadOperationEventMask; + Attributes::RemoteOperationEventMask::TypeInfo::DecodableType remoteOperationEventMask; + Attributes::ManualOperationEventMask::TypeInfo::DecodableType manualOperationEventMask; + Attributes::RFIDOperationEventMask::TypeInfo::DecodableType RFIDOperationEventMask; + Attributes::KeypadProgrammingEventMask::TypeInfo::DecodableType keypadProgrammingEventMask; + Attributes::RemoteProgrammingEventMask::TypeInfo::DecodableType remoteProgrammingEventMask; + Attributes::RFIDProgrammingEventMask::TypeInfo::DecodableType RFIDProgrammingEventMask; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes namespace Events { namespace DoorLockAlarm { @@ -18123,6 +19261,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace Type { struct TypeInfo { @@ -18483,6 +19622,47 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::WindowCovering::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::Type::TypeInfo::DecodableType type; + Attributes::PhysicalClosedLimitLift::TypeInfo::DecodableType physicalClosedLimitLift; + Attributes::PhysicalClosedLimitTilt::TypeInfo::DecodableType physicalClosedLimitTilt; + Attributes::CurrentPositionLift::TypeInfo::DecodableType currentPositionLift; + Attributes::CurrentPositionTilt::TypeInfo::DecodableType currentPositionTilt; + Attributes::NumberOfActuationsLift::TypeInfo::DecodableType numberOfActuationsLift; + Attributes::NumberOfActuationsTilt::TypeInfo::DecodableType numberOfActuationsTilt; + Attributes::ConfigStatus::TypeInfo::DecodableType configStatus; + Attributes::CurrentPositionLiftPercentage::TypeInfo::DecodableType currentPositionLiftPercentage; + Attributes::CurrentPositionTiltPercentage::TypeInfo::DecodableType currentPositionTiltPercentage; + Attributes::OperationalStatus::TypeInfo::DecodableType operationalStatus; + Attributes::TargetPositionLiftPercent100ths::TypeInfo::DecodableType targetPositionLiftPercent100ths; + Attributes::TargetPositionTiltPercent100ths::TypeInfo::DecodableType targetPositionTiltPercent100ths; + Attributes::EndProductType::TypeInfo::DecodableType endProductType; + Attributes::CurrentPositionLiftPercent100ths::TypeInfo::DecodableType currentPositionLiftPercent100ths; + Attributes::CurrentPositionTiltPercent100ths::TypeInfo::DecodableType currentPositionTiltPercent100ths; + Attributes::InstalledOpenLimitLift::TypeInfo::DecodableType installedOpenLimitLift; + Attributes::InstalledClosedLimitLift::TypeInfo::DecodableType installedClosedLimitLift; + Attributes::InstalledOpenLimitTilt::TypeInfo::DecodableType installedOpenLimitTilt; + Attributes::InstalledClosedLimitTilt::TypeInfo::DecodableType installedClosedLimitTilt; + Attributes::VelocityLift::TypeInfo::DecodableType velocityLift; + Attributes::AccelerationTimeLift::TypeInfo::DecodableType accelerationTimeLift; + Attributes::DecelerationTimeLift::TypeInfo::DecodableType decelerationTimeLift; + Attributes::Mode::TypeInfo::DecodableType mode; + Attributes::IntermediateSetpointsLift::TypeInfo::DecodableType intermediateSetpointsLift; + Attributes::IntermediateSetpointsTilt::TypeInfo::DecodableType intermediateSetpointsTilt; + Attributes::SafetyStatus::TypeInfo::DecodableType safetyStatus; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace WindowCovering namespace BarrierControl { @@ -18566,6 +19746,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace BarrierMovingState { struct TypeInfo { @@ -18722,6 +19903,30 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::BarrierControl::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::BarrierMovingState::TypeInfo::DecodableType barrierMovingState; + Attributes::BarrierSafetyStatus::TypeInfo::DecodableType barrierSafetyStatus; + Attributes::BarrierCapabilities::TypeInfo::DecodableType barrierCapabilities; + Attributes::BarrierOpenEvents::TypeInfo::DecodableType barrierOpenEvents; + Attributes::BarrierCloseEvents::TypeInfo::DecodableType barrierCloseEvents; + Attributes::BarrierCommandOpenEvents::TypeInfo::DecodableType barrierCommandOpenEvents; + Attributes::BarrierCommandCloseEvents::TypeInfo::DecodableType barrierCommandCloseEvents; + Attributes::BarrierOpenPeriod::TypeInfo::DecodableType barrierOpenPeriod; + Attributes::BarrierClosePeriod::TypeInfo::DecodableType barrierClosePeriod; + Attributes::BarrierPosition::TypeInfo::DecodableType barrierPosition; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace BarrierControl namespace PumpConfigurationAndControl { @@ -18759,6 +19964,7 @@ enum class PumpStatus : uint16_t }; namespace Attributes { + namespace MaxPressure { struct TypeInfo { @@ -19083,6 +20289,44 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::PumpConfigurationAndControl::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MaxPressure::TypeInfo::DecodableType maxPressure; + Attributes::MaxSpeed::TypeInfo::DecodableType maxSpeed; + Attributes::MaxFlow::TypeInfo::DecodableType maxFlow; + Attributes::MinConstPressure::TypeInfo::DecodableType minConstPressure; + Attributes::MaxConstPressure::TypeInfo::DecodableType maxConstPressure; + Attributes::MinCompPressure::TypeInfo::DecodableType minCompPressure; + Attributes::MaxCompPressure::TypeInfo::DecodableType maxCompPressure; + Attributes::MinConstSpeed::TypeInfo::DecodableType minConstSpeed; + Attributes::MaxConstSpeed::TypeInfo::DecodableType maxConstSpeed; + Attributes::MinConstFlow::TypeInfo::DecodableType minConstFlow; + Attributes::MaxConstFlow::TypeInfo::DecodableType maxConstFlow; + Attributes::MinConstTemp::TypeInfo::DecodableType minConstTemp; + Attributes::MaxConstTemp::TypeInfo::DecodableType maxConstTemp; + Attributes::PumpStatus::TypeInfo::DecodableType pumpStatus; + Attributes::EffectiveOperationMode::TypeInfo::DecodableType effectiveOperationMode; + Attributes::EffectiveControlMode::TypeInfo::DecodableType effectiveControlMode; + Attributes::Capacity::TypeInfo::DecodableType capacity; + Attributes::Speed::TypeInfo::DecodableType speed; + Attributes::LifetimeRunningHours::TypeInfo::DecodableType lifetimeRunningHours; + Attributes::Power::TypeInfo::DecodableType power; + Attributes::LifetimeEnergyConsumed::TypeInfo::DecodableType lifetimeEnergyConsumed; + Attributes::OperationMode::TypeInfo::DecodableType operationMode; + Attributes::ControlMode::TypeInfo::DecodableType controlMode; + Attributes::AlarmMask::TypeInfo::DecodableType alarmMask; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes namespace Events { namespace SupplyVoltageLow { @@ -19908,6 +21152,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace LocalTemperature { struct TypeInfo { @@ -20460,11 +21705,69 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::LocalTemperature::TypeInfo::DecodableType localTemperature; + Attributes::OutdoorTemperature::TypeInfo::DecodableType outdoorTemperature; + Attributes::Occupancy::TypeInfo::DecodableType occupancy; + Attributes::AbsMinHeatSetpointLimit::TypeInfo::DecodableType absMinHeatSetpointLimit; + Attributes::AbsMaxHeatSetpointLimit::TypeInfo::DecodableType absMaxHeatSetpointLimit; + Attributes::AbsMinCoolSetpointLimit::TypeInfo::DecodableType absMinCoolSetpointLimit; + Attributes::AbsMaxCoolSetpointLimit::TypeInfo::DecodableType absMaxCoolSetpointLimit; + Attributes::PiCoolingDemand::TypeInfo::DecodableType piCoolingDemand; + Attributes::PiHeatingDemand::TypeInfo::DecodableType piHeatingDemand; + Attributes::HvacSystemTypeConfiguration::TypeInfo::DecodableType hvacSystemTypeConfiguration; + Attributes::LocalTemperatureCalibration::TypeInfo::DecodableType localTemperatureCalibration; + Attributes::OccupiedCoolingSetpoint::TypeInfo::DecodableType occupiedCoolingSetpoint; + Attributes::OccupiedHeatingSetpoint::TypeInfo::DecodableType occupiedHeatingSetpoint; + Attributes::UnoccupiedCoolingSetpoint::TypeInfo::DecodableType unoccupiedCoolingSetpoint; + Attributes::UnoccupiedHeatingSetpoint::TypeInfo::DecodableType unoccupiedHeatingSetpoint; + Attributes::MinHeatSetpointLimit::TypeInfo::DecodableType minHeatSetpointLimit; + Attributes::MaxHeatSetpointLimit::TypeInfo::DecodableType maxHeatSetpointLimit; + Attributes::MinCoolSetpointLimit::TypeInfo::DecodableType minCoolSetpointLimit; + Attributes::MaxCoolSetpointLimit::TypeInfo::DecodableType maxCoolSetpointLimit; + Attributes::MinSetpointDeadBand::TypeInfo::DecodableType minSetpointDeadBand; + Attributes::RemoteSensing::TypeInfo::DecodableType remoteSensing; + Attributes::ControlSequenceOfOperation::TypeInfo::DecodableType controlSequenceOfOperation; + Attributes::SystemMode::TypeInfo::DecodableType systemMode; + Attributes::AlarmMask::TypeInfo::DecodableType alarmMask; + Attributes::ThermostatRunningMode::TypeInfo::DecodableType thermostatRunningMode; + Attributes::StartOfWeek::TypeInfo::DecodableType startOfWeek; + Attributes::NumberOfWeeklyTransitions::TypeInfo::DecodableType numberOfWeeklyTransitions; + Attributes::NumberOfDailyTransitions::TypeInfo::DecodableType numberOfDailyTransitions; + Attributes::TemperatureSetpointHold::TypeInfo::DecodableType temperatureSetpointHold; + Attributes::TemperatureSetpointHoldDuration::TypeInfo::DecodableType temperatureSetpointHoldDuration; + Attributes::ThermostatProgrammingOperationMode::TypeInfo::DecodableType thermostatProgrammingOperationMode; + Attributes::ThermostatRunningState::TypeInfo::DecodableType thermostatRunningState; + Attributes::SetpointChangeSource::TypeInfo::DecodableType setpointChangeSource; + Attributes::SetpointChangeAmount::TypeInfo::DecodableType setpointChangeAmount; + Attributes::SetpointChangeSourceTimestamp::TypeInfo::DecodableType setpointChangeSourceTimestamp; + Attributes::AcType::TypeInfo::DecodableType acType; + Attributes::AcCapacity::TypeInfo::DecodableType acCapacity; + Attributes::AcRefrigerantType::TypeInfo::DecodableType acRefrigerantType; + Attributes::AcCompressor::TypeInfo::DecodableType acCompressor; + Attributes::AcErrorCode::TypeInfo::DecodableType acErrorCode; + Attributes::AcLouverPosition::TypeInfo::DecodableType acLouverPosition; + Attributes::AcCoilTemperature::TypeInfo::DecodableType acCoilTemperature; + Attributes::AcCapacityFormat::TypeInfo::DecodableType acCapacityFormat; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace Thermostat namespace FanControl { namespace Attributes { + namespace FanMode { struct TypeInfo { @@ -20525,11 +21828,28 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::FanControl::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::FanMode::TypeInfo::DecodableType fanMode; + Attributes::FanModeSequence::TypeInfo::DecodableType fanModeSequence; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace FanControl namespace DehumidificationControl { namespace Attributes { + namespace RelativeHumidity { struct TypeInfo { @@ -20662,11 +21982,34 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::DehumidificationControl::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::RelativeHumidity::TypeInfo::DecodableType relativeHumidity; + Attributes::DehumidificationCooling::TypeInfo::DecodableType dehumidificationCooling; + Attributes::RhDehumidificationSetpoint::TypeInfo::DecodableType rhDehumidificationSetpoint; + Attributes::RelativeHumidityMode::TypeInfo::DecodableType relativeHumidityMode; + Attributes::DehumidificationLockout::TypeInfo::DecodableType dehumidificationLockout; + Attributes::DehumidificationHysteresis::TypeInfo::DecodableType dehumidificationHysteresis; + Attributes::DehumidificationMaxCool::TypeInfo::DecodableType dehumidificationMaxCool; + Attributes::RelativeHumidityDisplay::TypeInfo::DecodableType relativeHumidityDisplay; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace DehumidificationControl namespace ThermostatUserInterfaceConfiguration { namespace Attributes { + namespace TemperatureDisplayMode { struct TypeInfo { @@ -20739,6 +22082,23 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::ThermostatUserInterfaceConfiguration::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::TemperatureDisplayMode::TypeInfo::DecodableType temperatureDisplayMode; + Attributes::KeypadLockout::TypeInfo::DecodableType keypadLockout; + Attributes::ScheduleProgrammingVisibility::TypeInfo::DecodableType scheduleProgrammingVisibility; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace ThermostatUserInterfaceConfiguration namespace ColorControl { @@ -21792,6 +23152,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace CurrentHue { struct TypeInfo { @@ -22452,11 +23813,78 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::ColorControl::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::CurrentHue::TypeInfo::DecodableType currentHue; + Attributes::CurrentSaturation::TypeInfo::DecodableType currentSaturation; + Attributes::RemainingTime::TypeInfo::DecodableType remainingTime; + Attributes::CurrentX::TypeInfo::DecodableType currentX; + Attributes::CurrentY::TypeInfo::DecodableType currentY; + Attributes::DriftCompensation::TypeInfo::DecodableType driftCompensation; + Attributes::CompensationText::TypeInfo::DecodableType compensationText; + Attributes::ColorTemperature::TypeInfo::DecodableType colorTemperature; + Attributes::ColorMode::TypeInfo::DecodableType colorMode; + Attributes::ColorControlOptions::TypeInfo::DecodableType colorControlOptions; + Attributes::NumberOfPrimaries::TypeInfo::DecodableType numberOfPrimaries; + Attributes::Primary1X::TypeInfo::DecodableType primary1X; + Attributes::Primary1Y::TypeInfo::DecodableType primary1Y; + Attributes::Primary1Intensity::TypeInfo::DecodableType primary1Intensity; + Attributes::Primary2X::TypeInfo::DecodableType primary2X; + Attributes::Primary2Y::TypeInfo::DecodableType primary2Y; + Attributes::Primary2Intensity::TypeInfo::DecodableType primary2Intensity; + Attributes::Primary3X::TypeInfo::DecodableType primary3X; + Attributes::Primary3Y::TypeInfo::DecodableType primary3Y; + Attributes::Primary3Intensity::TypeInfo::DecodableType primary3Intensity; + Attributes::Primary4X::TypeInfo::DecodableType primary4X; + Attributes::Primary4Y::TypeInfo::DecodableType primary4Y; + Attributes::Primary4Intensity::TypeInfo::DecodableType primary4Intensity; + Attributes::Primary5X::TypeInfo::DecodableType primary5X; + Attributes::Primary5Y::TypeInfo::DecodableType primary5Y; + Attributes::Primary5Intensity::TypeInfo::DecodableType primary5Intensity; + Attributes::Primary6X::TypeInfo::DecodableType primary6X; + Attributes::Primary6Y::TypeInfo::DecodableType primary6Y; + Attributes::Primary6Intensity::TypeInfo::DecodableType primary6Intensity; + Attributes::WhitePointX::TypeInfo::DecodableType whitePointX; + Attributes::WhitePointY::TypeInfo::DecodableType whitePointY; + Attributes::ColorPointRX::TypeInfo::DecodableType colorPointRX; + Attributes::ColorPointRY::TypeInfo::DecodableType colorPointRY; + Attributes::ColorPointRIntensity::TypeInfo::DecodableType colorPointRIntensity; + Attributes::ColorPointGX::TypeInfo::DecodableType colorPointGX; + Attributes::ColorPointGY::TypeInfo::DecodableType colorPointGY; + Attributes::ColorPointGIntensity::TypeInfo::DecodableType colorPointGIntensity; + Attributes::ColorPointBX::TypeInfo::DecodableType colorPointBX; + Attributes::ColorPointBY::TypeInfo::DecodableType colorPointBY; + Attributes::ColorPointBIntensity::TypeInfo::DecodableType colorPointBIntensity; + Attributes::EnhancedCurrentHue::TypeInfo::DecodableType enhancedCurrentHue; + Attributes::EnhancedColorMode::TypeInfo::DecodableType enhancedColorMode; + Attributes::ColorLoopActive::TypeInfo::DecodableType colorLoopActive; + Attributes::ColorLoopDirection::TypeInfo::DecodableType colorLoopDirection; + Attributes::ColorLoopTime::TypeInfo::DecodableType colorLoopTime; + Attributes::ColorLoopStartEnhancedHue::TypeInfo::DecodableType colorLoopStartEnhancedHue; + Attributes::ColorLoopStoredEnhancedHue::TypeInfo::DecodableType colorLoopStoredEnhancedHue; + Attributes::ColorCapabilities::TypeInfo::DecodableType colorCapabilities; + Attributes::ColorTempPhysicalMin::TypeInfo::DecodableType colorTempPhysicalMin; + Attributes::ColorTempPhysicalMax::TypeInfo::DecodableType colorTempPhysicalMax; + Attributes::CoupleColorTempToLevelMinMireds::TypeInfo::DecodableType coupleColorTempToLevelMinMireds; + Attributes::StartUpColorTemperatureMireds::TypeInfo::DecodableType startUpColorTemperatureMireds; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace ColorControl namespace BallastConfiguration { namespace Attributes { + namespace PhysicalMinLevel { struct TypeInfo { @@ -22685,6 +24113,36 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::BallastConfiguration::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::PhysicalMinLevel::TypeInfo::DecodableType physicalMinLevel; + Attributes::PhysicalMaxLevel::TypeInfo::DecodableType physicalMaxLevel; + Attributes::BallastStatus::TypeInfo::DecodableType ballastStatus; + Attributes::MinLevel::TypeInfo::DecodableType minLevel; + Attributes::MaxLevel::TypeInfo::DecodableType maxLevel; + Attributes::PowerOnLevel::TypeInfo::DecodableType powerOnLevel; + Attributes::PowerOnFadeTime::TypeInfo::DecodableType powerOnFadeTime; + Attributes::IntrinsicBallastFactor::TypeInfo::DecodableType intrinsicBallastFactor; + Attributes::BallastFactorAdjustment::TypeInfo::DecodableType ballastFactorAdjustment; + Attributes::LampQuality::TypeInfo::DecodableType lampQuality; + Attributes::LampType::TypeInfo::DecodableType lampType; + Attributes::LampManufacturer::TypeInfo::DecodableType lampManufacturer; + Attributes::LampRatedHours::TypeInfo::DecodableType lampRatedHours; + Attributes::LampBurnHours::TypeInfo::DecodableType lampBurnHours; + Attributes::LampAlarmMode::TypeInfo::DecodableType lampAlarmMode; + Attributes::LampBurnHoursTripPoint::TypeInfo::DecodableType lampBurnHoursTripPoint; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace BallastConfiguration namespace IlluminanceMeasurement { @@ -22696,6 +24154,7 @@ enum class LightSensorType : uint8_t }; namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -22792,11 +24251,31 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::IlluminanceMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::LightSensorType::TypeInfo::DecodableType lightSensorType; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace IlluminanceMeasurement namespace TemperatureMeasurement { namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -22881,11 +24360,30 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::TemperatureMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace TemperatureMeasurement namespace PressureMeasurement { namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -23030,11 +24528,35 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::PressureMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::ScaledValue::TypeInfo::DecodableType scaledValue; + Attributes::MinScaledValue::TypeInfo::DecodableType minScaledValue; + Attributes::MaxScaledValue::TypeInfo::DecodableType maxScaledValue; + Attributes::ScaledTolerance::TypeInfo::DecodableType scaledTolerance; + Attributes::Scale::TypeInfo::DecodableType scale; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace PressureMeasurement namespace FlowMeasurement { namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -23119,11 +24641,30 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::FlowMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace FlowMeasurement namespace RelativeHumidityMeasurement { namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -23208,11 +24749,30 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::RelativeHumidityMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace RelativeHumidityMeasurement namespace OccupancySensing { namespace Attributes { + namespace Occupancy { struct TypeInfo { @@ -23393,11 +24953,39 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::OccupancySensing::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::Occupancy::TypeInfo::DecodableType occupancy; + Attributes::OccupancySensorType::TypeInfo::DecodableType occupancySensorType; + Attributes::OccupancySensorTypeBitmap::TypeInfo::DecodableType occupancySensorTypeBitmap; + Attributes::PirOccupiedToUnoccupiedDelay::TypeInfo::DecodableType pirOccupiedToUnoccupiedDelay; + Attributes::PirUnoccupiedToOccupiedDelay::TypeInfo::DecodableType pirUnoccupiedToOccupiedDelay; + Attributes::PirUnoccupiedToOccupiedThreshold::TypeInfo::DecodableType pirUnoccupiedToOccupiedThreshold; + Attributes::UltrasonicOccupiedToUnoccupiedDelay::TypeInfo::DecodableType ultrasonicOccupiedToUnoccupiedDelay; + Attributes::UltrasonicUnoccupiedToOccupiedDelay::TypeInfo::DecodableType ultrasonicUnoccupiedToOccupiedDelay; + Attributes::UltrasonicUnoccupiedToOccupiedThreshold::TypeInfo::DecodableType ultrasonicUnoccupiedToOccupiedThreshold; + Attributes::PhysicalContactOccupiedToUnoccupiedDelay::TypeInfo::DecodableType physicalContactOccupiedToUnoccupiedDelay; + Attributes::PhysicalContactUnoccupiedToOccupiedDelay::TypeInfo::DecodableType physicalContactUnoccupiedToOccupiedDelay; + Attributes::PhysicalContactUnoccupiedToOccupiedThreshold::TypeInfo::DecodableType + physicalContactUnoccupiedToOccupiedThreshold; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace OccupancySensing namespace CarbonMonoxideConcentrationMeasurement { namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -23482,11 +25070,30 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::CarbonMonoxideConcentrationMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace CarbonMonoxideConcentrationMeasurement namespace CarbonDioxideConcentrationMeasurement { namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -23571,11 +25178,30 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::CarbonDioxideConcentrationMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace CarbonDioxideConcentrationMeasurement namespace EthyleneConcentrationMeasurement { namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -23660,11 +25286,30 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::EthyleneConcentrationMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace EthyleneConcentrationMeasurement namespace EthyleneOxideConcentrationMeasurement { namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -23749,11 +25394,30 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::EthyleneOxideConcentrationMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace EthyleneOxideConcentrationMeasurement namespace HydrogenConcentrationMeasurement { namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -23838,11 +25502,30 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::HydrogenConcentrationMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace HydrogenConcentrationMeasurement namespace HydrogenSulphideConcentrationMeasurement { namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -23927,11 +25610,30 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::HydrogenSulphideConcentrationMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace HydrogenSulphideConcentrationMeasurement namespace NitricOxideConcentrationMeasurement { namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -24016,11 +25718,30 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::NitricOxideConcentrationMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace NitricOxideConcentrationMeasurement namespace NitrogenDioxideConcentrationMeasurement { namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -24105,11 +25826,30 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::NitrogenDioxideConcentrationMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace NitrogenDioxideConcentrationMeasurement namespace OxygenConcentrationMeasurement { namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -24194,11 +25934,30 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::OxygenConcentrationMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace OxygenConcentrationMeasurement namespace OzoneConcentrationMeasurement { namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -24283,11 +26042,30 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::OzoneConcentrationMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace OzoneConcentrationMeasurement namespace SulfurDioxideConcentrationMeasurement { namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -24372,11 +26150,30 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::SulfurDioxideConcentrationMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace SulfurDioxideConcentrationMeasurement namespace DissolvedOxygenConcentrationMeasurement { namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -24461,11 +26258,30 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::DissolvedOxygenConcentrationMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace DissolvedOxygenConcentrationMeasurement namespace BromateConcentrationMeasurement { namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -24550,11 +26366,30 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::BromateConcentrationMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace BromateConcentrationMeasurement namespace ChloraminesConcentrationMeasurement { namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -24639,11 +26474,30 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::ChloraminesConcentrationMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace ChloraminesConcentrationMeasurement namespace ChlorineConcentrationMeasurement { namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -24728,11 +26582,30 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::ChlorineConcentrationMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace ChlorineConcentrationMeasurement namespace FecalColiformAndEColiConcentrationMeasurement { namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -24817,11 +26690,30 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::FecalColiformAndEColiConcentrationMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace FecalColiformAndEColiConcentrationMeasurement namespace FluorideConcentrationMeasurement { namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -24906,11 +26798,30 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::FluorideConcentrationMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace FluorideConcentrationMeasurement namespace HaloaceticAcidsConcentrationMeasurement { namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -24995,11 +26906,30 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::HaloaceticAcidsConcentrationMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace HaloaceticAcidsConcentrationMeasurement namespace TotalTrihalomethanesConcentrationMeasurement { namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -25084,11 +27014,30 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::TotalTrihalomethanesConcentrationMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace TotalTrihalomethanesConcentrationMeasurement namespace TotalColiformBacteriaConcentrationMeasurement { namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -25173,11 +27122,30 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::TotalColiformBacteriaConcentrationMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace TotalColiformBacteriaConcentrationMeasurement namespace TurbidityConcentrationMeasurement { namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -25262,11 +27230,30 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::TurbidityConcentrationMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace TurbidityConcentrationMeasurement namespace CopperConcentrationMeasurement { namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -25351,11 +27338,30 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::CopperConcentrationMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace CopperConcentrationMeasurement namespace LeadConcentrationMeasurement { namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -25440,11 +27446,30 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::LeadConcentrationMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace LeadConcentrationMeasurement namespace ManganeseConcentrationMeasurement { namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -25529,11 +27554,30 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::ManganeseConcentrationMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace ManganeseConcentrationMeasurement namespace SulfateConcentrationMeasurement { namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -25618,11 +27662,30 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::SulfateConcentrationMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace SulfateConcentrationMeasurement namespace BromodichloromethaneConcentrationMeasurement { namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -25707,11 +27770,30 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::BromodichloromethaneConcentrationMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace BromodichloromethaneConcentrationMeasurement namespace BromoformConcentrationMeasurement { namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -25796,11 +27878,30 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::BromoformConcentrationMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace BromoformConcentrationMeasurement namespace ChlorodibromomethaneConcentrationMeasurement { namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -25885,11 +27986,30 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::ChlorodibromomethaneConcentrationMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace ChlorodibromomethaneConcentrationMeasurement namespace ChloroformConcentrationMeasurement { namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -25974,11 +28094,30 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::ChloroformConcentrationMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace ChloroformConcentrationMeasurement namespace SodiumConcentrationMeasurement { namespace Attributes { + namespace MeasuredValue { struct TypeInfo { @@ -26063,6 +28202,24 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::SodiumConcentrationMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasuredValue::TypeInfo::DecodableType measuredValue; + Attributes::MinMeasuredValue::TypeInfo::DecodableType minMeasuredValue; + Attributes::MaxMeasuredValue::TypeInfo::DecodableType maxMeasuredValue; + Attributes::Tolerance::TypeInfo::DecodableType tolerance; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace SodiumConcentrationMeasurement namespace IasZone { @@ -26396,6 +28553,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace ZoneState { struct TypeInfo { @@ -26516,6 +28674,27 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::IasZone::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::ZoneState::TypeInfo::DecodableType zoneState; + Attributes::ZoneType::TypeInfo::DecodableType zoneType; + Attributes::ZoneStatus::TypeInfo::DecodableType zoneStatus; + Attributes::IasCieAddress::TypeInfo::DecodableType iasCieAddress; + Attributes::ZoneId::TypeInfo::DecodableType zoneId; + Attributes::NumberOfZoneSensitivityLevelsSupported::TypeInfo::DecodableType numberOfZoneSensitivityLevelsSupported; + Attributes::CurrentZoneSensitivityLevel::TypeInfo::DecodableType currentZoneSensitivityLevel; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace IasZone namespace IasAce { @@ -27447,6 +29626,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace AttributeList { struct TypeInfo { @@ -27483,6 +29663,20 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::IasAce::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace IasAce namespace IasWd { @@ -27595,6 +29789,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace MaxDuration { struct TypeInfo { @@ -27643,11 +29838,27 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::IasWd::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MaxDuration::TypeInfo::DecodableType maxDuration; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace IasWd namespace WakeOnLan { namespace Attributes { + namespace WakeOnLanMacAddress { struct TypeInfo { @@ -27696,6 +29907,21 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::WakeOnLan::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::WakeOnLanMacAddress::TypeInfo::DecodableType wakeOnLanMacAddress; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace WakeOnLan namespace TvChannel { @@ -27927,6 +30153,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace ChannelList { struct TypeInfo { @@ -27999,6 +30226,23 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::TvChannel::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::ChannelList::TypeInfo::DecodableType channelList; + Attributes::ChannelLineup::TypeInfo::DecodableType channelLineup; + Attributes::CurrentChannel::TypeInfo::DecodableType currentChannel; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace TvChannel namespace TargetNavigator { @@ -28122,6 +30366,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace TargetNavigatorList { struct TypeInfo { @@ -28182,6 +30427,22 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::TargetNavigator::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::TargetNavigatorList::TypeInfo::DecodableType targetNavigatorList; + Attributes::CurrentNavigatorTarget::TypeInfo::DecodableType currentNavigatorTarget; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace TargetNavigator namespace MediaPlayback { @@ -29030,6 +31291,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace PlaybackState { struct TypeInfo { @@ -29150,6 +31412,27 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::MediaPlayback::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::PlaybackState::TypeInfo::DecodableType playbackState; + Attributes::StartTime::TypeInfo::DecodableType startTime; + Attributes::Duration::TypeInfo::DecodableType duration; + Attributes::Position::TypeInfo::DecodableType position; + Attributes::PlaybackSpeed::TypeInfo::DecodableType playbackSpeed; + Attributes::SeekRangeEnd::TypeInfo::DecodableType seekRangeEnd; + Attributes::SeekRangeStart::TypeInfo::DecodableType seekRangeStart; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace MediaPlayback namespace MediaInput { @@ -29355,6 +31638,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace MediaInputList { struct TypeInfo { @@ -29415,6 +31699,22 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::MediaInput::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MediaInputList::TypeInfo::DecodableType mediaInputList; + Attributes::CurrentMediaInput::TypeInfo::DecodableType currentMediaInput; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace MediaInput namespace LowPower { @@ -29461,6 +31761,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace AttributeList { struct TypeInfo { @@ -29497,6 +31798,20 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::LowPower::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace LowPower namespace KeypadInput { @@ -29693,6 +32008,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace AttributeList { struct TypeInfo { @@ -29729,6 +32045,20 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::KeypadInput::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace KeypadInput namespace ContentLauncher { @@ -30067,6 +32397,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace AcceptsHeaderList { struct TypeInfo { @@ -30127,6 +32458,22 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::ContentLauncher::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::AcceptsHeaderList::TypeInfo::DecodableType acceptsHeaderList; + Attributes::SupportedStreamingProtocols::TypeInfo::DecodableType supportedStreamingProtocols; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace ContentLauncher namespace AudioOutput { @@ -30258,6 +32605,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace AudioOutputList { struct TypeInfo { @@ -30318,6 +32666,22 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::AudioOutput::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::AudioOutputList::TypeInfo::DecodableType audioOutputList; + Attributes::CurrentAudioOutput::TypeInfo::DecodableType currentAudioOutput; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace AudioOutput namespace ApplicationLauncher { @@ -30621,6 +32985,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace ApplicationLauncherList { struct TypeInfo { @@ -30681,6 +33046,22 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::ApplicationLauncher::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::ApplicationLauncherList::TypeInfo::DecodableType applicationLauncherList; + Attributes::ApplicationLauncherApp::TypeInfo::DecodableType applicationLauncherApp; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace ApplicationLauncher namespace ApplicationBasic { @@ -30762,6 +33143,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace VendorName { struct TypeInfo { @@ -30882,6 +33264,27 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::ApplicationBasic::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::VendorName::TypeInfo::DecodableType vendorName; + Attributes::VendorId::TypeInfo::DecodableType vendorId; + Attributes::ApplicationName::TypeInfo::DecodableType applicationName; + Attributes::ProductId::TypeInfo::DecodableType productId; + Attributes::ApplicationApp::TypeInfo::DecodableType applicationApp; + Attributes::ApplicationStatus::TypeInfo::DecodableType applicationStatus; + Attributes::ApplicationVersion::TypeInfo::DecodableType applicationVersion; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace ApplicationBasic namespace AccountLogin { @@ -31042,6 +33445,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace AttributeList { struct TypeInfo { @@ -31078,6 +33482,20 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::AccountLogin::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace AccountLogin namespace TestCluster { @@ -32633,6 +35051,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace Boolean { struct TypeInfo { @@ -33077,7 +35496,7 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace EnumAttr -namespace Struct { +namespace StructAttr { struct TypeInfo { using Type = Structs::SimpleStruct::Type; @@ -33085,10 +35504,10 @@ struct TypeInfo using DecodableArgType = const Structs::SimpleStruct::DecodableType &; static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } - static constexpr AttributeId GetAttributeId() { return Attributes::Struct::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::StructAttr::Id; } static constexpr bool MustUseTimedWrite() { return false; } }; -} // namespace Struct +} // namespace StructAttr namespace RangeRestrictedInt8u { struct TypeInfo { @@ -33605,6 +36024,98 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::Boolean::TypeInfo::DecodableType boolean; + Attributes::Bitmap8::TypeInfo::DecodableType bitmap8; + Attributes::Bitmap16::TypeInfo::DecodableType bitmap16; + Attributes::Bitmap32::TypeInfo::DecodableType bitmap32; + Attributes::Bitmap64::TypeInfo::DecodableType bitmap64; + Attributes::Int8u::TypeInfo::DecodableType int8u; + Attributes::Int16u::TypeInfo::DecodableType int16u; + Attributes::Int24u::TypeInfo::DecodableType int24u; + Attributes::Int32u::TypeInfo::DecodableType int32u; + Attributes::Int40u::TypeInfo::DecodableType int40u; + Attributes::Int48u::TypeInfo::DecodableType int48u; + Attributes::Int56u::TypeInfo::DecodableType int56u; + Attributes::Int64u::TypeInfo::DecodableType int64u; + Attributes::Int8s::TypeInfo::DecodableType int8s; + Attributes::Int16s::TypeInfo::DecodableType int16s; + Attributes::Int24s::TypeInfo::DecodableType int24s; + Attributes::Int32s::TypeInfo::DecodableType int32s; + Attributes::Int40s::TypeInfo::DecodableType int40s; + Attributes::Int48s::TypeInfo::DecodableType int48s; + Attributes::Int56s::TypeInfo::DecodableType int56s; + Attributes::Int64s::TypeInfo::DecodableType int64s; + Attributes::Enum8::TypeInfo::DecodableType enum8; + Attributes::Enum16::TypeInfo::DecodableType enum16; + Attributes::FloatSingle::TypeInfo::DecodableType floatSingle; + Attributes::FloatDouble::TypeInfo::DecodableType floatDouble; + Attributes::OctetString::TypeInfo::DecodableType octetString; + Attributes::ListInt8u::TypeInfo::DecodableType listInt8u; + Attributes::ListOctetString::TypeInfo::DecodableType listOctetString; + Attributes::ListStructOctetString::TypeInfo::DecodableType listStructOctetString; + Attributes::LongOctetString::TypeInfo::DecodableType longOctetString; + Attributes::CharString::TypeInfo::DecodableType charString; + Attributes::LongCharString::TypeInfo::DecodableType longCharString; + Attributes::EpochUs::TypeInfo::DecodableType epochUs; + Attributes::EpochS::TypeInfo::DecodableType epochS; + Attributes::VendorId::TypeInfo::DecodableType vendorId; + Attributes::ListNullablesAndOptionalsStruct::TypeInfo::DecodableType listNullablesAndOptionalsStruct; + Attributes::EnumAttr::TypeInfo::DecodableType enumAttr; + Attributes::StructAttr::TypeInfo::DecodableType structAttr; + Attributes::RangeRestrictedInt8u::TypeInfo::DecodableType rangeRestrictedInt8u; + Attributes::RangeRestrictedInt8s::TypeInfo::DecodableType rangeRestrictedInt8s; + Attributes::RangeRestrictedInt16u::TypeInfo::DecodableType rangeRestrictedInt16u; + Attributes::RangeRestrictedInt16s::TypeInfo::DecodableType rangeRestrictedInt16s; + Attributes::ListLongOctetString::TypeInfo::DecodableType listLongOctetString; + Attributes::TimedWriteBoolean::TypeInfo::DecodableType timedWriteBoolean; + Attributes::Unsupported::TypeInfo::DecodableType unsupported; + Attributes::NullableBoolean::TypeInfo::DecodableType nullableBoolean; + Attributes::NullableBitmap8::TypeInfo::DecodableType nullableBitmap8; + Attributes::NullableBitmap16::TypeInfo::DecodableType nullableBitmap16; + Attributes::NullableBitmap32::TypeInfo::DecodableType nullableBitmap32; + Attributes::NullableBitmap64::TypeInfo::DecodableType nullableBitmap64; + Attributes::NullableInt8u::TypeInfo::DecodableType nullableInt8u; + Attributes::NullableInt16u::TypeInfo::DecodableType nullableInt16u; + Attributes::NullableInt24u::TypeInfo::DecodableType nullableInt24u; + Attributes::NullableInt32u::TypeInfo::DecodableType nullableInt32u; + Attributes::NullableInt40u::TypeInfo::DecodableType nullableInt40u; + Attributes::NullableInt48u::TypeInfo::DecodableType nullableInt48u; + Attributes::NullableInt56u::TypeInfo::DecodableType nullableInt56u; + Attributes::NullableInt64u::TypeInfo::DecodableType nullableInt64u; + Attributes::NullableInt8s::TypeInfo::DecodableType nullableInt8s; + Attributes::NullableInt16s::TypeInfo::DecodableType nullableInt16s; + Attributes::NullableInt24s::TypeInfo::DecodableType nullableInt24s; + Attributes::NullableInt32s::TypeInfo::DecodableType nullableInt32s; + Attributes::NullableInt40s::TypeInfo::DecodableType nullableInt40s; + Attributes::NullableInt48s::TypeInfo::DecodableType nullableInt48s; + Attributes::NullableInt56s::TypeInfo::DecodableType nullableInt56s; + Attributes::NullableInt64s::TypeInfo::DecodableType nullableInt64s; + Attributes::NullableEnum8::TypeInfo::DecodableType nullableEnum8; + Attributes::NullableEnum16::TypeInfo::DecodableType nullableEnum16; + Attributes::NullableFloatSingle::TypeInfo::DecodableType nullableFloatSingle; + Attributes::NullableFloatDouble::TypeInfo::DecodableType nullableFloatDouble; + Attributes::NullableOctetString::TypeInfo::DecodableType nullableOctetString; + Attributes::NullableCharString::TypeInfo::DecodableType nullableCharString; + Attributes::NullableEnumAttr::TypeInfo::DecodableType nullableEnumAttr; + Attributes::NullableStruct::TypeInfo::DecodableType nullableStruct; + Attributes::NullableRangeRestrictedInt8u::TypeInfo::DecodableType nullableRangeRestrictedInt8u; + Attributes::NullableRangeRestrictedInt8s::TypeInfo::DecodableType nullableRangeRestrictedInt8s; + Attributes::NullableRangeRestrictedInt16u::TypeInfo::DecodableType nullableRangeRestrictedInt16u; + Attributes::NullableRangeRestrictedInt16s::TypeInfo::DecodableType nullableRangeRestrictedInt16s; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes namespace Events { namespace TestEvent { @@ -34100,6 +36611,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace AttributeList { struct TypeInfo { @@ -34136,11 +36648,26 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::Messaging::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace Messaging namespace ApplianceIdentification { namespace Attributes { + namespace BasicIdentification { struct TypeInfo { @@ -34321,11 +36848,38 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::ApplianceIdentification::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::BasicIdentification::TypeInfo::DecodableType basicIdentification; + Attributes::CompanyName::TypeInfo::DecodableType companyName; + Attributes::CompanyId::TypeInfo::DecodableType companyId; + Attributes::BrandName::TypeInfo::DecodableType brandName; + Attributes::BrandId::TypeInfo::DecodableType brandId; + Attributes::Model::TypeInfo::DecodableType model; + Attributes::PartNumber::TypeInfo::DecodableType partNumber; + Attributes::ProductRevision::TypeInfo::DecodableType productRevision; + Attributes::SoftwareRevision::TypeInfo::DecodableType softwareRevision; + Attributes::ProductTypeName::TypeInfo::DecodableType productTypeName; + Attributes::ProductTypeId::TypeInfo::DecodableType productTypeId; + Attributes::CecedSpecificationVersion::TypeInfo::DecodableType cecedSpecificationVersion; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace ApplianceIdentification namespace MeterIdentification { namespace Attributes { + namespace CompanyName { struct TypeInfo { @@ -34506,6 +37060,32 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::MeterIdentification::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::CompanyName::TypeInfo::DecodableType companyName; + Attributes::MeterTypeId::TypeInfo::DecodableType meterTypeId; + Attributes::DataQualityId::TypeInfo::DecodableType dataQualityId; + Attributes::CustomerName::TypeInfo::DecodableType customerName; + Attributes::Model::TypeInfo::DecodableType model; + Attributes::PartNumber::TypeInfo::DecodableType partNumber; + Attributes::ProductRevision::TypeInfo::DecodableType productRevision; + Attributes::SoftwareRevision::TypeInfo::DecodableType softwareRevision; + Attributes::UtilityName::TypeInfo::DecodableType utilityName; + Attributes::Pod::TypeInfo::DecodableType pod; + Attributes::AvailablePower::TypeInfo::DecodableType availablePower; + Attributes::PowerThreshold::TypeInfo::DecodableType powerThreshold; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace MeterIdentification namespace ApplianceEventsAndAlert { @@ -34696,6 +37276,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace AttributeList { struct TypeInfo { @@ -34732,6 +37313,20 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::ApplianceEventsAndAlert::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace ApplianceEventsAndAlert namespace ApplianceStatistics { @@ -34987,6 +37582,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace LogMaxSize { struct TypeInfo { @@ -35047,6 +37643,22 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::ApplianceStatistics::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::LogMaxSize::TypeInfo::DecodableType logMaxSize; + Attributes::LogQueueMaxSize::TypeInfo::DecodableType logQueueMaxSize; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace ApplianceStatistics namespace ElectricalMeasurement { @@ -35234,6 +37846,7 @@ struct DecodableType } // namespace Commands namespace Attributes { + namespace MeasurementType { struct TypeInfo { @@ -36806,6 +39419,148 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::ElectricalMeasurement::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::MeasurementType::TypeInfo::DecodableType measurementType; + Attributes::DcVoltage::TypeInfo::DecodableType dcVoltage; + Attributes::DcVoltageMin::TypeInfo::DecodableType dcVoltageMin; + Attributes::DcVoltageMax::TypeInfo::DecodableType dcVoltageMax; + Attributes::DcCurrent::TypeInfo::DecodableType dcCurrent; + Attributes::DcCurrentMin::TypeInfo::DecodableType dcCurrentMin; + Attributes::DcCurrentMax::TypeInfo::DecodableType dcCurrentMax; + Attributes::DcPower::TypeInfo::DecodableType dcPower; + Attributes::DcPowerMin::TypeInfo::DecodableType dcPowerMin; + Attributes::DcPowerMax::TypeInfo::DecodableType dcPowerMax; + Attributes::DcVoltageMultiplier::TypeInfo::DecodableType dcVoltageMultiplier; + Attributes::DcVoltageDivisor::TypeInfo::DecodableType dcVoltageDivisor; + Attributes::DcCurrentMultiplier::TypeInfo::DecodableType dcCurrentMultiplier; + Attributes::DcCurrentDivisor::TypeInfo::DecodableType dcCurrentDivisor; + Attributes::DcPowerMultiplier::TypeInfo::DecodableType dcPowerMultiplier; + Attributes::DcPowerDivisor::TypeInfo::DecodableType dcPowerDivisor; + Attributes::AcFrequency::TypeInfo::DecodableType acFrequency; + Attributes::AcFrequencyMin::TypeInfo::DecodableType acFrequencyMin; + Attributes::AcFrequencyMax::TypeInfo::DecodableType acFrequencyMax; + Attributes::NeutralCurrent::TypeInfo::DecodableType neutralCurrent; + Attributes::TotalActivePower::TypeInfo::DecodableType totalActivePower; + Attributes::TotalReactivePower::TypeInfo::DecodableType totalReactivePower; + Attributes::TotalApparentPower::TypeInfo::DecodableType totalApparentPower; + Attributes::Measured1stHarmonicCurrent::TypeInfo::DecodableType measured1stHarmonicCurrent; + Attributes::Measured3rdHarmonicCurrent::TypeInfo::DecodableType measured3rdHarmonicCurrent; + Attributes::Measured5thHarmonicCurrent::TypeInfo::DecodableType measured5thHarmonicCurrent; + Attributes::Measured7thHarmonicCurrent::TypeInfo::DecodableType measured7thHarmonicCurrent; + Attributes::Measured9thHarmonicCurrent::TypeInfo::DecodableType measured9thHarmonicCurrent; + Attributes::Measured11thHarmonicCurrent::TypeInfo::DecodableType measured11thHarmonicCurrent; + Attributes::MeasuredPhase1stHarmonicCurrent::TypeInfo::DecodableType measuredPhase1stHarmonicCurrent; + Attributes::MeasuredPhase3rdHarmonicCurrent::TypeInfo::DecodableType measuredPhase3rdHarmonicCurrent; + Attributes::MeasuredPhase5thHarmonicCurrent::TypeInfo::DecodableType measuredPhase5thHarmonicCurrent; + Attributes::MeasuredPhase7thHarmonicCurrent::TypeInfo::DecodableType measuredPhase7thHarmonicCurrent; + Attributes::MeasuredPhase9thHarmonicCurrent::TypeInfo::DecodableType measuredPhase9thHarmonicCurrent; + Attributes::MeasuredPhase11thHarmonicCurrent::TypeInfo::DecodableType measuredPhase11thHarmonicCurrent; + Attributes::AcFrequencyMultiplier::TypeInfo::DecodableType acFrequencyMultiplier; + Attributes::AcFrequencyDivisor::TypeInfo::DecodableType acFrequencyDivisor; + Attributes::PowerMultiplier::TypeInfo::DecodableType powerMultiplier; + Attributes::PowerDivisor::TypeInfo::DecodableType powerDivisor; + Attributes::HarmonicCurrentMultiplier::TypeInfo::DecodableType harmonicCurrentMultiplier; + Attributes::PhaseHarmonicCurrentMultiplier::TypeInfo::DecodableType phaseHarmonicCurrentMultiplier; + Attributes::InstantaneousVoltage::TypeInfo::DecodableType instantaneousVoltage; + Attributes::InstantaneousLineCurrent::TypeInfo::DecodableType instantaneousLineCurrent; + Attributes::InstantaneousActiveCurrent::TypeInfo::DecodableType instantaneousActiveCurrent; + Attributes::InstantaneousReactiveCurrent::TypeInfo::DecodableType instantaneousReactiveCurrent; + Attributes::InstantaneousPower::TypeInfo::DecodableType instantaneousPower; + Attributes::RmsVoltage::TypeInfo::DecodableType rmsVoltage; + Attributes::RmsVoltageMin::TypeInfo::DecodableType rmsVoltageMin; + Attributes::RmsVoltageMax::TypeInfo::DecodableType rmsVoltageMax; + Attributes::RmsCurrent::TypeInfo::DecodableType rmsCurrent; + Attributes::RmsCurrentMin::TypeInfo::DecodableType rmsCurrentMin; + Attributes::RmsCurrentMax::TypeInfo::DecodableType rmsCurrentMax; + Attributes::ActivePower::TypeInfo::DecodableType activePower; + Attributes::ActivePowerMin::TypeInfo::DecodableType activePowerMin; + Attributes::ActivePowerMax::TypeInfo::DecodableType activePowerMax; + Attributes::ReactivePower::TypeInfo::DecodableType reactivePower; + Attributes::ApparentPower::TypeInfo::DecodableType apparentPower; + Attributes::PowerFactor::TypeInfo::DecodableType powerFactor; + Attributes::AverageRmsVoltageMeasurementPeriod::TypeInfo::DecodableType averageRmsVoltageMeasurementPeriod; + Attributes::AverageRmsUnderVoltageCounter::TypeInfo::DecodableType averageRmsUnderVoltageCounter; + Attributes::RmsExtremeOverVoltagePeriod::TypeInfo::DecodableType rmsExtremeOverVoltagePeriod; + Attributes::RmsExtremeUnderVoltagePeriod::TypeInfo::DecodableType rmsExtremeUnderVoltagePeriod; + Attributes::RmsVoltageSagPeriod::TypeInfo::DecodableType rmsVoltageSagPeriod; + Attributes::RmsVoltageSwellPeriod::TypeInfo::DecodableType rmsVoltageSwellPeriod; + Attributes::AcVoltageMultiplier::TypeInfo::DecodableType acVoltageMultiplier; + Attributes::AcVoltageDivisor::TypeInfo::DecodableType acVoltageDivisor; + Attributes::AcCurrentMultiplier::TypeInfo::DecodableType acCurrentMultiplier; + Attributes::AcCurrentDivisor::TypeInfo::DecodableType acCurrentDivisor; + Attributes::AcPowerMultiplier::TypeInfo::DecodableType acPowerMultiplier; + Attributes::AcPowerDivisor::TypeInfo::DecodableType acPowerDivisor; + Attributes::OverloadAlarmsMask::TypeInfo::DecodableType overloadAlarmsMask; + Attributes::VoltageOverload::TypeInfo::DecodableType voltageOverload; + Attributes::CurrentOverload::TypeInfo::DecodableType currentOverload; + Attributes::AcOverloadAlarmsMask::TypeInfo::DecodableType acOverloadAlarmsMask; + Attributes::AcVoltageOverload::TypeInfo::DecodableType acVoltageOverload; + Attributes::AcCurrentOverload::TypeInfo::DecodableType acCurrentOverload; + Attributes::AcActivePowerOverload::TypeInfo::DecodableType acActivePowerOverload; + Attributes::AcReactivePowerOverload::TypeInfo::DecodableType acReactivePowerOverload; + Attributes::AverageRmsOverVoltage::TypeInfo::DecodableType averageRmsOverVoltage; + Attributes::AverageRmsUnderVoltage::TypeInfo::DecodableType averageRmsUnderVoltage; + Attributes::RmsExtremeOverVoltage::TypeInfo::DecodableType rmsExtremeOverVoltage; + Attributes::RmsExtremeUnderVoltage::TypeInfo::DecodableType rmsExtremeUnderVoltage; + Attributes::RmsVoltageSag::TypeInfo::DecodableType rmsVoltageSag; + Attributes::RmsVoltageSwell::TypeInfo::DecodableType rmsVoltageSwell; + Attributes::LineCurrentPhaseB::TypeInfo::DecodableType lineCurrentPhaseB; + Attributes::ActiveCurrentPhaseB::TypeInfo::DecodableType activeCurrentPhaseB; + Attributes::ReactiveCurrentPhaseB::TypeInfo::DecodableType reactiveCurrentPhaseB; + Attributes::RmsVoltagePhaseB::TypeInfo::DecodableType rmsVoltagePhaseB; + Attributes::RmsVoltageMinPhaseB::TypeInfo::DecodableType rmsVoltageMinPhaseB; + Attributes::RmsVoltageMaxPhaseB::TypeInfo::DecodableType rmsVoltageMaxPhaseB; + Attributes::RmsCurrentPhaseB::TypeInfo::DecodableType rmsCurrentPhaseB; + Attributes::RmsCurrentMinPhaseB::TypeInfo::DecodableType rmsCurrentMinPhaseB; + Attributes::RmsCurrentMaxPhaseB::TypeInfo::DecodableType rmsCurrentMaxPhaseB; + Attributes::ActivePowerPhaseB::TypeInfo::DecodableType activePowerPhaseB; + Attributes::ActivePowerMinPhaseB::TypeInfo::DecodableType activePowerMinPhaseB; + Attributes::ActivePowerMaxPhaseB::TypeInfo::DecodableType activePowerMaxPhaseB; + Attributes::ReactivePowerPhaseB::TypeInfo::DecodableType reactivePowerPhaseB; + Attributes::ApparentPowerPhaseB::TypeInfo::DecodableType apparentPowerPhaseB; + Attributes::PowerFactorPhaseB::TypeInfo::DecodableType powerFactorPhaseB; + Attributes::AverageRmsVoltageMeasurementPeriodPhaseB::TypeInfo::DecodableType averageRmsVoltageMeasurementPeriodPhaseB; + Attributes::AverageRmsOverVoltageCounterPhaseB::TypeInfo::DecodableType averageRmsOverVoltageCounterPhaseB; + Attributes::AverageRmsUnderVoltageCounterPhaseB::TypeInfo::DecodableType averageRmsUnderVoltageCounterPhaseB; + Attributes::RmsExtremeOverVoltagePeriodPhaseB::TypeInfo::DecodableType rmsExtremeOverVoltagePeriodPhaseB; + Attributes::RmsExtremeUnderVoltagePeriodPhaseB::TypeInfo::DecodableType rmsExtremeUnderVoltagePeriodPhaseB; + Attributes::RmsVoltageSagPeriodPhaseB::TypeInfo::DecodableType rmsVoltageSagPeriodPhaseB; + Attributes::RmsVoltageSwellPeriodPhaseB::TypeInfo::DecodableType rmsVoltageSwellPeriodPhaseB; + Attributes::LineCurrentPhaseC::TypeInfo::DecodableType lineCurrentPhaseC; + Attributes::ActiveCurrentPhaseC::TypeInfo::DecodableType activeCurrentPhaseC; + Attributes::ReactiveCurrentPhaseC::TypeInfo::DecodableType reactiveCurrentPhaseC; + Attributes::RmsVoltagePhaseC::TypeInfo::DecodableType rmsVoltagePhaseC; + Attributes::RmsVoltageMinPhaseC::TypeInfo::DecodableType rmsVoltageMinPhaseC; + Attributes::RmsVoltageMaxPhaseC::TypeInfo::DecodableType rmsVoltageMaxPhaseC; + Attributes::RmsCurrentPhaseC::TypeInfo::DecodableType rmsCurrentPhaseC; + Attributes::RmsCurrentMinPhaseC::TypeInfo::DecodableType rmsCurrentMinPhaseC; + Attributes::RmsCurrentMaxPhaseC::TypeInfo::DecodableType rmsCurrentMaxPhaseC; + Attributes::ActivePowerPhaseC::TypeInfo::DecodableType activePowerPhaseC; + Attributes::ActivePowerMinPhaseC::TypeInfo::DecodableType activePowerMinPhaseC; + Attributes::ActivePowerMaxPhaseC::TypeInfo::DecodableType activePowerMaxPhaseC; + Attributes::ReactivePowerPhaseC::TypeInfo::DecodableType reactivePowerPhaseC; + Attributes::ApparentPowerPhaseC::TypeInfo::DecodableType apparentPowerPhaseC; + Attributes::PowerFactorPhaseC::TypeInfo::DecodableType powerFactorPhaseC; + Attributes::AverageRmsVoltageMeasurementPeriodPhaseC::TypeInfo::DecodableType averageRmsVoltageMeasurementPeriodPhaseC; + Attributes::AverageRmsOverVoltageCounterPhaseC::TypeInfo::DecodableType averageRmsOverVoltageCounterPhaseC; + Attributes::AverageRmsUnderVoltageCounterPhaseC::TypeInfo::DecodableType averageRmsUnderVoltageCounterPhaseC; + Attributes::RmsExtremeOverVoltagePeriodPhaseC::TypeInfo::DecodableType rmsExtremeOverVoltagePeriodPhaseC; + Attributes::RmsExtremeUnderVoltagePeriodPhaseC::TypeInfo::DecodableType rmsExtremeUnderVoltagePeriodPhaseC; + Attributes::RmsVoltageSagPeriodPhaseC::TypeInfo::DecodableType rmsVoltageSagPeriodPhaseC; + Attributes::RmsVoltageSwellPeriodPhaseC::TypeInfo::DecodableType rmsVoltageSwellPeriodPhaseC; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap; + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision; + }; +}; } // namespace Attributes } // namespace ElectricalMeasurement diff --git a/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h b/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h index 08263aa5cf1acb..4794917210dd97 100644 --- a/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h +++ b/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h @@ -5242,9 +5242,9 @@ namespace EnumAttr { static constexpr AttributeId Id = 0x00000024; } // namespace EnumAttr -namespace Struct { +namespace StructAttr { static constexpr AttributeId Id = 0x00000025; -} // namespace Struct +} // namespace StructAttr namespace RangeRestrictedInt8u { static constexpr AttributeId Id = 0x00000026; diff --git a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h index f5214a39dea4fc..79266bd70cd6de 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h +++ b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h @@ -33159,7 +33159,7 @@ class ReportTemperatureMeasurementClusterRevision : public ModelCommand | * VendorId | 0x0022 | | * ListNullablesAndOptionalsStruct | 0x0023 | | * EnumAttr | 0x0024 | -| * Struct | 0x0025 | +| * StructAttr | 0x0025 | | * RangeRestrictedInt8u | 0x0026 | | * RangeRestrictedInt8s | 0x0027 | | * RangeRestrictedInt16u | 0x0028 |