From c8027a5f50b10409b108f1d58d990f9b8f6bd435 Mon Sep 17 00:00:00 2001 From: Jerry Johns Date: Mon, 13 Dec 2021 17:20:15 -0800 Subject: [PATCH] Read/Subscribe Attribute Cache (#11938) * Read-Only Attribute Cache 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. Tests: Unit-test * Apply suggestions from code review Co-authored-by: Boris Zbarsky * Review feedback * Restyle Co-authored-by: Boris Zbarsky --- src/app/AttributeCache.cpp | 217 + src/app/AttributeCache.h | 365 ++ src/app/BUILD.gn | 2 + src/app/ConcreteAttributePath.h | 8 +- .../test-cluster-server.cpp | 4 +- src/app/data-model/Decode.h | 28 + src/app/tests/BUILD.gn | 1 + src/app/tests/TestAttributeCache.cpp | 558 ++ .../templates/app/cluster-objects-src.zapt | 17 + .../templates/app/cluster-objects.zapt | 22 +- .../zcl/data-model/chip/test-cluster.xml | 2 +- .../java/zap-generated/CHIPCallbackTypes.h | 4 +- .../python/chip/clusters/CHIPClusters.py | 2 +- .../python/chip/clusters/Objects.py | 6 +- .../test/test_scripts/cluster_objects.py | 2 +- .../CHIPAttributeTLVValueDecoder.mm | 4 +- .../zap-generated/endpoint_config.h | 2 +- .../zap-generated/cluster-objects.cpp | 5575 ++++++++++++++++- .../zap-generated/cluster-objects.h | 2761 +++++++- .../app-common/zap-generated/ids/Attributes.h | 4 +- .../zap-generated/cluster/Commands.h | 2 +- 21 files changed, 9558 insertions(+), 28 deletions(-) create mode 100644 src/app/AttributeCache.cpp create mode 100644 src/app/AttributeCache.h create mode 100644 src/app/tests/TestAttributeCache.cpp 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 |