From f0ebdd3b4113f084c399eedcd0d31bc0504603e4 Mon Sep 17 00:00:00 2001 From: Hare Date: Wed, 17 May 2023 10:19:53 +0800 Subject: [PATCH] Regenerating all possible code using zap tool --- .../data_model/controller-clusters.zap | 8 +- .../devicecontroller/ClusterReadMapping.java | 238 ++++ .../devicecontroller/ClusterWriteMapping.java | 20 + .../CHIPAttributeTLVValueDecoder.cpp | 316 +++++ .../zap-generated/CHIPClustersWrite-JNI.cpp | 52 + .../CHIPEventTLVValueDecoder.cpp | 299 +++++ .../java/zap-generated/CHIPReadCallbacks.cpp | 282 ++++ .../chip/devicecontroller/ChipClusters.java | 351 +++++ .../devicecontroller/ChipEventStructs.java | 143 ++ .../chip/devicecontroller/ChipIdLookup.java | 96 ++ .../devicecontroller/ClusterInfoMapping.java | 116 ++ .../python/chip/clusters/CHIPClusters.py | 125 ++ .../zap-generated/CHIPClientCallbacks.h | 1148 +++++++++++------ .../zap-generated/CHIPClusters.h | 344 +++-- .../zap-generated/IMClusterCommandHandler.cpp | 14 +- .../zap-generated/endpoint_config.h | 77 +- .../zap-generated/gen_config.h | 80 -- 17 files changed, 3134 insertions(+), 575 deletions(-) diff --git a/src/controller/data_model/controller-clusters.zap b/src/controller/data_model/controller-clusters.zap index 5ffcb8679c8d6c..338f53f316ba2b 100644 --- a/src/controller/data_model/controller-clusters.zap +++ b/src/controller/data_model/controller-clusters.zap @@ -10699,7 +10699,7 @@ "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -10715,7 +10715,7 @@ "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -10731,7 +10731,7 @@ "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -10747,7 +10747,7 @@ "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java index 20574c1135c838..c27f127d0a9158 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java @@ -7243,6 +7243,243 @@ private static Map readAirQualityInteractionInfo() { return result; } + private static Map readSmokeCoAlarmInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readSmokeCoAlarmExpressedStateCommandParams = + new LinkedHashMap(); + InteractionInfo readSmokeCoAlarmExpressedStateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SmokeCoAlarmCluster) cluster) + .readExpressedStateAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSmokeCoAlarmExpressedStateCommandParams); + result.put( + "readExpressedStateAttribute", readSmokeCoAlarmExpressedStateAttributeInteractionInfo); + Map readSmokeCoAlarmSmokeStateCommandParams = + new LinkedHashMap(); + InteractionInfo readSmokeCoAlarmSmokeStateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SmokeCoAlarmCluster) cluster) + .readSmokeStateAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSmokeCoAlarmSmokeStateCommandParams); + result.put("readSmokeStateAttribute", readSmokeCoAlarmSmokeStateAttributeInteractionInfo); + Map readSmokeCoAlarmCOStateCommandParams = + new LinkedHashMap(); + InteractionInfo readSmokeCoAlarmCOStateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SmokeCoAlarmCluster) cluster) + .readCOStateAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSmokeCoAlarmCOStateCommandParams); + result.put("readCOStateAttribute", readSmokeCoAlarmCOStateAttributeInteractionInfo); + Map readSmokeCoAlarmBatteryAlertCommandParams = + new LinkedHashMap(); + InteractionInfo readSmokeCoAlarmBatteryAlertAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SmokeCoAlarmCluster) cluster) + .readBatteryAlertAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSmokeCoAlarmBatteryAlertCommandParams); + result.put("readBatteryAlertAttribute", readSmokeCoAlarmBatteryAlertAttributeInteractionInfo); + Map readSmokeCoAlarmDeviceMutedCommandParams = + new LinkedHashMap(); + InteractionInfo readSmokeCoAlarmDeviceMutedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SmokeCoAlarmCluster) cluster) + .readDeviceMutedAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSmokeCoAlarmDeviceMutedCommandParams); + result.put("readDeviceMutedAttribute", readSmokeCoAlarmDeviceMutedAttributeInteractionInfo); + Map readSmokeCoAlarmTestInProgressCommandParams = + new LinkedHashMap(); + InteractionInfo readSmokeCoAlarmTestInProgressAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SmokeCoAlarmCluster) cluster) + .readTestInProgressAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readSmokeCoAlarmTestInProgressCommandParams); + result.put( + "readTestInProgressAttribute", readSmokeCoAlarmTestInProgressAttributeInteractionInfo); + Map readSmokeCoAlarmHardwareFaultAlertCommandParams = + new LinkedHashMap(); + InteractionInfo readSmokeCoAlarmHardwareFaultAlertAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SmokeCoAlarmCluster) cluster) + .readHardwareFaultAlertAttribute( + (ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readSmokeCoAlarmHardwareFaultAlertCommandParams); + result.put( + "readHardwareFaultAlertAttribute", + readSmokeCoAlarmHardwareFaultAlertAttributeInteractionInfo); + Map readSmokeCoAlarmEndOfServiceAlertCommandParams = + new LinkedHashMap(); + InteractionInfo readSmokeCoAlarmEndOfServiceAlertAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SmokeCoAlarmCluster) cluster) + .readEndOfServiceAlertAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSmokeCoAlarmEndOfServiceAlertCommandParams); + result.put( + "readEndOfServiceAlertAttribute", + readSmokeCoAlarmEndOfServiceAlertAttributeInteractionInfo); + Map readSmokeCoAlarmInterconnectSmokeAlarmCommandParams = + new LinkedHashMap(); + InteractionInfo readSmokeCoAlarmInterconnectSmokeAlarmAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SmokeCoAlarmCluster) cluster) + .readInterconnectSmokeAlarmAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSmokeCoAlarmInterconnectSmokeAlarmCommandParams); + result.put( + "readInterconnectSmokeAlarmAttribute", + readSmokeCoAlarmInterconnectSmokeAlarmAttributeInteractionInfo); + Map readSmokeCoAlarmInterconnectCOAlarmCommandParams = + new LinkedHashMap(); + InteractionInfo readSmokeCoAlarmInterconnectCOAlarmAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SmokeCoAlarmCluster) cluster) + .readInterconnectCOAlarmAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSmokeCoAlarmInterconnectCOAlarmCommandParams); + result.put( + "readInterconnectCOAlarmAttribute", + readSmokeCoAlarmInterconnectCOAlarmAttributeInteractionInfo); + Map readSmokeCoAlarmContaminationStateCommandParams = + new LinkedHashMap(); + InteractionInfo readSmokeCoAlarmContaminationStateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SmokeCoAlarmCluster) cluster) + .readContaminationStateAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSmokeCoAlarmContaminationStateCommandParams); + result.put( + "readContaminationStateAttribute", + readSmokeCoAlarmContaminationStateAttributeInteractionInfo); + Map readSmokeCoAlarmSensitivityLevelCommandParams = + new LinkedHashMap(); + InteractionInfo readSmokeCoAlarmSensitivityLevelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SmokeCoAlarmCluster) cluster) + .readSensitivityLevelAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSmokeCoAlarmSensitivityLevelCommandParams); + result.put( + "readSensitivityLevelAttribute", readSmokeCoAlarmSensitivityLevelAttributeInteractionInfo); + Map readSmokeCoAlarmGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readSmokeCoAlarmGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SmokeCoAlarmCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.SmokeCoAlarmCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedSmokeCoAlarmClusterGeneratedCommandListAttributeCallback(), + readSmokeCoAlarmGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readSmokeCoAlarmGeneratedCommandListAttributeInteractionInfo); + Map readSmokeCoAlarmAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readSmokeCoAlarmAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SmokeCoAlarmCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.SmokeCoAlarmCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedSmokeCoAlarmClusterAcceptedCommandListAttributeCallback(), + readSmokeCoAlarmAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readSmokeCoAlarmAcceptedCommandListAttributeInteractionInfo); + Map readSmokeCoAlarmEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readSmokeCoAlarmEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SmokeCoAlarmCluster) cluster) + .readEventListAttribute( + (ChipClusters.SmokeCoAlarmCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedSmokeCoAlarmClusterEventListAttributeCallback(), + readSmokeCoAlarmEventListCommandParams); + result.put("readEventListAttribute", readSmokeCoAlarmEventListAttributeInteractionInfo); + Map readSmokeCoAlarmAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readSmokeCoAlarmAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SmokeCoAlarmCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.SmokeCoAlarmCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedSmokeCoAlarmClusterAttributeListAttributeCallback(), + readSmokeCoAlarmAttributeListCommandParams); + result.put("readAttributeListAttribute", readSmokeCoAlarmAttributeListAttributeInteractionInfo); + Map readSmokeCoAlarmFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readSmokeCoAlarmFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SmokeCoAlarmCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readSmokeCoAlarmFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readSmokeCoAlarmFeatureMapAttributeInteractionInfo); + Map readSmokeCoAlarmClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readSmokeCoAlarmClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SmokeCoAlarmCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSmokeCoAlarmClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", readSmokeCoAlarmClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readHepaFilterMonitoringInteractionInfo() { Map result = new LinkedHashMap<>(); Map readHepaFilterMonitoringConditionCommandParams = @@ -18559,6 +18796,7 @@ public Map> getReadAttributeMap() { put("icdManagement", readIcdManagementInteractionInfo()); put("modeSelect", readModeSelectInteractionInfo()); put("airQuality", readAirQualityInteractionInfo()); + put("smokeCoAlarm", readSmokeCoAlarmInteractionInfo()); put("hepaFilterMonitoring", readHepaFilterMonitoringInteractionInfo()); put( "activatedCarbonFilterMonitoring", diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java index c3d7038d4358b6..8d7e39b91a9465 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java @@ -629,6 +629,26 @@ public Map> getWriteAttributeMap() { writeAttributeMap.put("modeSelect", writeModeSelectInteractionInfo); Map writeAirQualityInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("airQuality", writeAirQualityInteractionInfo); + Map writeSmokeCoAlarmInteractionInfo = new LinkedHashMap<>(); + Map writeSmokeCoAlarmSensitivityLevelCommandParams = + new LinkedHashMap(); + CommandParameterInfo smokeCoAlarmsensitivityLevelCommandParameterInfo = + new CommandParameterInfo("value", Integer.class, Integer.class); + writeSmokeCoAlarmSensitivityLevelCommandParams.put( + "value", smokeCoAlarmsensitivityLevelCommandParameterInfo); + InteractionInfo writeSmokeCoAlarmSensitivityLevelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SmokeCoAlarmCluster) cluster) + .writeSensitivityLevelAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeSmokeCoAlarmSensitivityLevelCommandParams); + writeSmokeCoAlarmInteractionInfo.put( + "writeSensitivityLevelAttribute", + writeSmokeCoAlarmSensitivityLevelAttributeInteractionInfo); + writeAttributeMap.put("smokeCoAlarm", writeSmokeCoAlarmInteractionInfo); Map writeHepaFilterMonitoringInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("hepaFilterMonitoring", writeHepaFilterMonitoringInteractionInfo); Map writeActivatedCarbonFilterMonitoringInteractionInfo = diff --git a/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp b/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp index f8a1f257a0af6b..35dfa7bcff785b 100644 --- a/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp +++ b/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp @@ -11294,6 +11294,322 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR } break; } + case app::Clusters::SmokeCoAlarm::Id: { + using namespace app::Clusters::SmokeCoAlarm; + switch (aPath.mAttributeId) + { + case Attributes::ExpressedState::Id: { + using TypeInfo = Attributes::ExpressedState::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + std::string valueClassName = "java/lang/Integer"; + std::string valueCtorSignature = "(I)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), + static_cast(cppValue), value); + return value; + } + case Attributes::SmokeState::Id: { + using TypeInfo = Attributes::SmokeState::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + std::string valueClassName = "java/lang/Integer"; + std::string valueCtorSignature = "(I)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), + static_cast(cppValue), value); + return value; + } + case Attributes::COState::Id: { + using TypeInfo = Attributes::COState::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + std::string valueClassName = "java/lang/Integer"; + std::string valueCtorSignature = "(I)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), + static_cast(cppValue), value); + return value; + } + case Attributes::BatteryAlert::Id: { + using TypeInfo = Attributes::BatteryAlert::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + std::string valueClassName = "java/lang/Integer"; + std::string valueCtorSignature = "(I)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), + static_cast(cppValue), value); + return value; + } + case Attributes::DeviceMuted::Id: { + using TypeInfo = Attributes::DeviceMuted::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + std::string valueClassName = "java/lang/Integer"; + std::string valueCtorSignature = "(I)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), + static_cast(cppValue), value); + return value; + } + case Attributes::TestInProgress::Id: { + using TypeInfo = Attributes::TestInProgress::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + std::string valueClassName = "java/lang/Boolean"; + std::string valueCtorSignature = "(Z)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), cppValue, + value); + return value; + } + case Attributes::HardwareFaultAlert::Id: { + using TypeInfo = Attributes::HardwareFaultAlert::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + std::string valueClassName = "java/lang/Boolean"; + std::string valueCtorSignature = "(Z)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), cppValue, + value); + return value; + } + case Attributes::EndOfServiceAlert::Id: { + using TypeInfo = Attributes::EndOfServiceAlert::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + std::string valueClassName = "java/lang/Integer"; + std::string valueCtorSignature = "(I)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), + static_cast(cppValue), value); + return value; + } + case Attributes::InterconnectSmokeAlarm::Id: { + using TypeInfo = Attributes::InterconnectSmokeAlarm::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + std::string valueClassName = "java/lang/Integer"; + std::string valueCtorSignature = "(I)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), + static_cast(cppValue), value); + return value; + } + case Attributes::InterconnectCOAlarm::Id: { + using TypeInfo = Attributes::InterconnectCOAlarm::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + std::string valueClassName = "java/lang/Integer"; + std::string valueCtorSignature = "(I)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), + static_cast(cppValue), value); + return value; + } + case Attributes::ContaminationState::Id: { + using TypeInfo = Attributes::ContaminationState::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + std::string valueClassName = "java/lang/Integer"; + std::string valueCtorSignature = "(I)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), + static_cast(cppValue), value); + return value; + } + case Attributes::SensitivityLevel::Id: { + using TypeInfo = Attributes::SensitivityLevel::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + std::string valueClassName = "java/lang/Integer"; + std::string valueCtorSignature = "(I)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), + static_cast(cppValue), value); + return value; + } + case Attributes::GeneratedCommandList::Id: { + using TypeInfo = Attributes::GeneratedCommandList::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + chip::JniReferences::GetInstance().CreateArrayList(value); + + auto iter_value_0 = cppValue.begin(); + while (iter_value_0.Next()) + { + auto & entry_0 = iter_value_0.GetValue(); + jobject newElement_0; + std::string newElement_0ClassName = "java/lang/Long"; + std::string newElement_0CtorSignature = "(J)V"; + chip::JniReferences::GetInstance().CreateBoxedObject( + newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), entry_0, newElement_0); + chip::JniReferences::GetInstance().AddToList(value, newElement_0); + } + return value; + } + case Attributes::AcceptedCommandList::Id: { + using TypeInfo = Attributes::AcceptedCommandList::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + chip::JniReferences::GetInstance().CreateArrayList(value); + + auto iter_value_0 = cppValue.begin(); + while (iter_value_0.Next()) + { + auto & entry_0 = iter_value_0.GetValue(); + jobject newElement_0; + std::string newElement_0ClassName = "java/lang/Long"; + std::string newElement_0CtorSignature = "(J)V"; + chip::JniReferences::GetInstance().CreateBoxedObject( + newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), entry_0, newElement_0); + chip::JniReferences::GetInstance().AddToList(value, newElement_0); + } + return value; + } + case Attributes::EventList::Id: { + using TypeInfo = Attributes::EventList::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + chip::JniReferences::GetInstance().CreateArrayList(value); + + auto iter_value_0 = cppValue.begin(); + while (iter_value_0.Next()) + { + auto & entry_0 = iter_value_0.GetValue(); + jobject newElement_0; + std::string newElement_0ClassName = "java/lang/Long"; + std::string newElement_0CtorSignature = "(J)V"; + chip::JniReferences::GetInstance().CreateBoxedObject( + newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), entry_0, newElement_0); + chip::JniReferences::GetInstance().AddToList(value, newElement_0); + } + return value; + } + case Attributes::AttributeList::Id: { + using TypeInfo = Attributes::AttributeList::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + chip::JniReferences::GetInstance().CreateArrayList(value); + + auto iter_value_0 = cppValue.begin(); + while (iter_value_0.Next()) + { + auto & entry_0 = iter_value_0.GetValue(); + jobject newElement_0; + std::string newElement_0ClassName = "java/lang/Long"; + std::string newElement_0CtorSignature = "(J)V"; + chip::JniReferences::GetInstance().CreateBoxedObject( + newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), entry_0, newElement_0); + chip::JniReferences::GetInstance().AddToList(value, newElement_0); + } + return value; + } + case Attributes::FeatureMap::Id: { + using TypeInfo = Attributes::FeatureMap::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + std::string valueClassName = "java/lang/Long"; + std::string valueCtorSignature = "(J)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), + cppValue, value); + return value; + } + case Attributes::ClusterRevision::Id: { + using TypeInfo = Attributes::ClusterRevision::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + std::string valueClassName = "java/lang/Integer"; + std::string valueCtorSignature = "(I)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), + cppValue, value); + return value; + } + default: + *aError = CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_PATH_IB; + break; + } + break; + } case app::Clusters::HepaFilterMonitoring::Id: { using namespace app::Clusters::HepaFilterMonitoring; switch (aPath.mAttributeId) diff --git a/src/controller/java/zap-generated/CHIPClustersWrite-JNI.cpp b/src/controller/java/zap-generated/CHIPClustersWrite-JNI.cpp index 704671c5d5fa20..b55e2d66de81f9 100644 --- a/src/controller/java/zap-generated/CHIPClustersWrite-JNI.cpp +++ b/src/controller/java/zap-generated/CHIPClustersWrite-JNI.cpp @@ -2342,6 +2342,58 @@ JNI_METHOD(void, ModeSelectCluster, writeOnModeAttribute) onFailure.release(); } +JNI_METHOD(void, SmokeCoAlarmCluster, writeSensitivityLevelAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value, jobject timedWriteTimeoutMs) +{ + chip::DeviceLayer::StackLock lock; + ListFreer listFreer; + using TypeInfo = chip::app::Clusters::SmokeCoAlarm::Attributes::SensitivityLevel::TypeInfo; + TypeInfo::Type cppValue; + + std::vector> cleanupByteArrays; + std::vector> cleanupStrings; + + cppValue = + static_cast>(chip::JniReferences::GetInstance().IntegerToPrimitive(value)); + + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + SmokeCoAlarmCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + + if (timedWriteTimeoutMs == nullptr) + { + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + } + else + { + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall, + chip::JniReferences::GetInstance().IntegerToPrimitive(timedWriteTimeoutMs)); + } + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + JNI_METHOD(void, DoorLockCluster, writeDoorOpenEventsAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value, jobject timedWriteTimeoutMs) { diff --git a/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp b/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp index ecbffc60ee818b..fbab8d85ee46b2 100644 --- a/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp +++ b/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp @@ -2221,6 +2221,305 @@ jobject DecodeEventValue(const app::ConcreteEventPath & aPath, TLV::TLVReader & } break; } + case app::Clusters::SmokeCoAlarm::Id: { + using namespace app::Clusters::SmokeCoAlarm; + switch (aPath.mEventId) + { + case Events::SmokeAlarm::Id: { + Events::SmokeAlarm::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jclass smokeAlarmStructClass; + err = chip::JniReferences::GetInstance().GetClassRef( + env, "chip/devicecontroller/ChipEventStructs$SmokeCoAlarmClusterSmokeAlarmEvent", smokeAlarmStructClass); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipEventStructs$SmokeCoAlarmClusterSmokeAlarmEvent"); + return nullptr; + } + jmethodID smokeAlarmStructCtor = env->GetMethodID(smokeAlarmStructClass, "", "()V"); + if (smokeAlarmStructCtor == nullptr) + { + ChipLogError(Zcl, "Could not find ChipEventStructs$SmokeCoAlarmClusterSmokeAlarmEvent constructor"); + return nullptr; + } + + jobject value = env->NewObject(smokeAlarmStructClass, smokeAlarmStructCtor); + + return value; + } + case Events::COAlarm::Id: { + Events::COAlarm::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jclass COAlarmStructClass; + err = chip::JniReferences::GetInstance().GetClassRef( + env, "chip/devicecontroller/ChipEventStructs$SmokeCoAlarmClusterCOAlarmEvent", COAlarmStructClass); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipEventStructs$SmokeCoAlarmClusterCOAlarmEvent"); + return nullptr; + } + jmethodID COAlarmStructCtor = env->GetMethodID(COAlarmStructClass, "", "()V"); + if (COAlarmStructCtor == nullptr) + { + ChipLogError(Zcl, "Could not find ChipEventStructs$SmokeCoAlarmClusterCOAlarmEvent constructor"); + return nullptr; + } + + jobject value = env->NewObject(COAlarmStructClass, COAlarmStructCtor); + + return value; + } + case Events::LowBattery::Id: { + Events::LowBattery::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jclass lowBatteryStructClass; + err = chip::JniReferences::GetInstance().GetClassRef( + env, "chip/devicecontroller/ChipEventStructs$SmokeCoAlarmClusterLowBatteryEvent", lowBatteryStructClass); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipEventStructs$SmokeCoAlarmClusterLowBatteryEvent"); + return nullptr; + } + jmethodID lowBatteryStructCtor = env->GetMethodID(lowBatteryStructClass, "", "()V"); + if (lowBatteryStructCtor == nullptr) + { + ChipLogError(Zcl, "Could not find ChipEventStructs$SmokeCoAlarmClusterLowBatteryEvent constructor"); + return nullptr; + } + + jobject value = env->NewObject(lowBatteryStructClass, lowBatteryStructCtor); + + return value; + } + case Events::HardwareFault::Id: { + Events::HardwareFault::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jclass hardwareFaultStructClass; + err = chip::JniReferences::GetInstance().GetClassRef( + env, "chip/devicecontroller/ChipEventStructs$SmokeCoAlarmClusterHardwareFaultEvent", hardwareFaultStructClass); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipEventStructs$SmokeCoAlarmClusterHardwareFaultEvent"); + return nullptr; + } + jmethodID hardwareFaultStructCtor = env->GetMethodID(hardwareFaultStructClass, "", "()V"); + if (hardwareFaultStructCtor == nullptr) + { + ChipLogError(Zcl, "Could not find ChipEventStructs$SmokeCoAlarmClusterHardwareFaultEvent constructor"); + return nullptr; + } + + jobject value = env->NewObject(hardwareFaultStructClass, hardwareFaultStructCtor); + + return value; + } + case Events::EndOfService::Id: { + Events::EndOfService::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jclass endOfServiceStructClass; + err = chip::JniReferences::GetInstance().GetClassRef( + env, "chip/devicecontroller/ChipEventStructs$SmokeCoAlarmClusterEndOfServiceEvent", endOfServiceStructClass); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipEventStructs$SmokeCoAlarmClusterEndOfServiceEvent"); + return nullptr; + } + jmethodID endOfServiceStructCtor = env->GetMethodID(endOfServiceStructClass, "", "()V"); + if (endOfServiceStructCtor == nullptr) + { + ChipLogError(Zcl, "Could not find ChipEventStructs$SmokeCoAlarmClusterEndOfServiceEvent constructor"); + return nullptr; + } + + jobject value = env->NewObject(endOfServiceStructClass, endOfServiceStructCtor); + + return value; + } + case Events::SelfTestComplete::Id: { + Events::SelfTestComplete::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jclass selfTestCompleteStructClass; + err = chip::JniReferences::GetInstance().GetClassRef( + env, "chip/devicecontroller/ChipEventStructs$SmokeCoAlarmClusterSelfTestCompleteEvent", + selfTestCompleteStructClass); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipEventStructs$SmokeCoAlarmClusterSelfTestCompleteEvent"); + return nullptr; + } + jmethodID selfTestCompleteStructCtor = env->GetMethodID(selfTestCompleteStructClass, "", "()V"); + if (selfTestCompleteStructCtor == nullptr) + { + ChipLogError(Zcl, "Could not find ChipEventStructs$SmokeCoAlarmClusterSelfTestCompleteEvent constructor"); + return nullptr; + } + + jobject value = env->NewObject(selfTestCompleteStructClass, selfTestCompleteStructCtor); + + return value; + } + case Events::AlarmMuted::Id: { + Events::AlarmMuted::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jclass alarmMutedStructClass; + err = chip::JniReferences::GetInstance().GetClassRef( + env, "chip/devicecontroller/ChipEventStructs$SmokeCoAlarmClusterAlarmMutedEvent", alarmMutedStructClass); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipEventStructs$SmokeCoAlarmClusterAlarmMutedEvent"); + return nullptr; + } + jmethodID alarmMutedStructCtor = env->GetMethodID(alarmMutedStructClass, "", "()V"); + if (alarmMutedStructCtor == nullptr) + { + ChipLogError(Zcl, "Could not find ChipEventStructs$SmokeCoAlarmClusterAlarmMutedEvent constructor"); + return nullptr; + } + + jobject value = env->NewObject(alarmMutedStructClass, alarmMutedStructCtor); + + return value; + } + case Events::MuteEnded::Id: { + Events::MuteEnded::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jclass muteEndedStructClass; + err = chip::JniReferences::GetInstance().GetClassRef( + env, "chip/devicecontroller/ChipEventStructs$SmokeCoAlarmClusterMuteEndedEvent", muteEndedStructClass); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipEventStructs$SmokeCoAlarmClusterMuteEndedEvent"); + return nullptr; + } + jmethodID muteEndedStructCtor = env->GetMethodID(muteEndedStructClass, "", "()V"); + if (muteEndedStructCtor == nullptr) + { + ChipLogError(Zcl, "Could not find ChipEventStructs$SmokeCoAlarmClusterMuteEndedEvent constructor"); + return nullptr; + } + + jobject value = env->NewObject(muteEndedStructClass, muteEndedStructCtor); + + return value; + } + case Events::InterconnectSmokeAlarm::Id: { + Events::InterconnectSmokeAlarm::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jclass interconnectSmokeAlarmStructClass; + err = chip::JniReferences::GetInstance().GetClassRef( + env, "chip/devicecontroller/ChipEventStructs$SmokeCoAlarmClusterInterconnectSmokeAlarmEvent", + interconnectSmokeAlarmStructClass); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipEventStructs$SmokeCoAlarmClusterInterconnectSmokeAlarmEvent"); + return nullptr; + } + jmethodID interconnectSmokeAlarmStructCtor = env->GetMethodID(interconnectSmokeAlarmStructClass, "", "()V"); + if (interconnectSmokeAlarmStructCtor == nullptr) + { + ChipLogError(Zcl, "Could not find ChipEventStructs$SmokeCoAlarmClusterInterconnectSmokeAlarmEvent constructor"); + return nullptr; + } + + jobject value = env->NewObject(interconnectSmokeAlarmStructClass, interconnectSmokeAlarmStructCtor); + + return value; + } + case Events::InterconnectCOAlarm::Id: { + Events::InterconnectCOAlarm::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jclass interconnectCOAlarmStructClass; + err = chip::JniReferences::GetInstance().GetClassRef( + env, "chip/devicecontroller/ChipEventStructs$SmokeCoAlarmClusterInterconnectCOAlarmEvent", + interconnectCOAlarmStructClass); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipEventStructs$SmokeCoAlarmClusterInterconnectCOAlarmEvent"); + return nullptr; + } + jmethodID interconnectCOAlarmStructCtor = env->GetMethodID(interconnectCOAlarmStructClass, "", "()V"); + if (interconnectCOAlarmStructCtor == nullptr) + { + ChipLogError(Zcl, "Could not find ChipEventStructs$SmokeCoAlarmClusterInterconnectCOAlarmEvent constructor"); + return nullptr; + } + + jobject value = env->NewObject(interconnectCOAlarmStructClass, interconnectCOAlarmStructCtor); + + return value; + } + case Events::AllClear::Id: { + Events::AllClear::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jclass allClearStructClass; + err = chip::JniReferences::GetInstance().GetClassRef( + env, "chip/devicecontroller/ChipEventStructs$SmokeCoAlarmClusterAllClearEvent", allClearStructClass); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipEventStructs$SmokeCoAlarmClusterAllClearEvent"); + return nullptr; + } + jmethodID allClearStructCtor = env->GetMethodID(allClearStructClass, "", "()V"); + if (allClearStructCtor == nullptr) + { + ChipLogError(Zcl, "Could not find ChipEventStructs$SmokeCoAlarmClusterAllClearEvent constructor"); + return nullptr; + } + + jobject value = env->NewObject(allClearStructClass, allClearStructCtor); + + return value; + } + default: + *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB; + break; + } + break; + } case app::Clusters::HepaFilterMonitoring::Id: { using namespace app::Clusters::HepaFilterMonitoring; switch (aPath.mEventId) diff --git a/src/controller/java/zap-generated/CHIPReadCallbacks.cpp b/src/controller/java/zap-generated/CHIPReadCallbacks.cpp index a46f9158eff9fd..d4bee798f0fe38 100644 --- a/src/controller/java/zap-generated/CHIPReadCallbacks.cpp +++ b/src/controller/java/zap-generated/CHIPReadCallbacks.cpp @@ -18677,6 +18677,288 @@ void CHIPAirQualityAttributeListAttributeCallback::CallbackFn(void * context, env->CallVoidMethod(javaCallbackRef, javaMethod, arrayListObj); } +CHIPSmokeCoAlarmGeneratedCommandListAttributeCallback::CHIPSmokeCoAlarmGeneratedCommandListAttributeCallback(jobject javaCallback, + bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPSmokeCoAlarmGeneratedCommandListAttributeCallback::~CHIPSmokeCoAlarmGeneratedCommandListAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPSmokeCoAlarmGeneratedCommandListAttributeCallback::CallbackFn( + void * context, const chip::app::DataModel::DecodableList & list) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/util/List;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject arrayListObj; + chip::JniReferences::GetInstance().CreateArrayList(arrayListObj); + + auto iter_arrayListObj_0 = list.begin(); + while (iter_arrayListObj_0.Next()) + { + auto & entry_0 = iter_arrayListObj_0.GetValue(); + jobject newElement_0; + std::string newElement_0ClassName = "java/lang/Long"; + std::string newElement_0CtorSignature = "(J)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(newElement_0ClassName.c_str(), + newElement_0CtorSignature.c_str(), entry_0, newElement_0); + chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0); + } + + env->ExceptionClear(); + env->CallVoidMethod(javaCallbackRef, javaMethod, arrayListObj); +} + +CHIPSmokeCoAlarmAcceptedCommandListAttributeCallback::CHIPSmokeCoAlarmAcceptedCommandListAttributeCallback(jobject javaCallback, + bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPSmokeCoAlarmAcceptedCommandListAttributeCallback::~CHIPSmokeCoAlarmAcceptedCommandListAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPSmokeCoAlarmAcceptedCommandListAttributeCallback::CallbackFn( + void * context, const chip::app::DataModel::DecodableList & list) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/util/List;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject arrayListObj; + chip::JniReferences::GetInstance().CreateArrayList(arrayListObj); + + auto iter_arrayListObj_0 = list.begin(); + while (iter_arrayListObj_0.Next()) + { + auto & entry_0 = iter_arrayListObj_0.GetValue(); + jobject newElement_0; + std::string newElement_0ClassName = "java/lang/Long"; + std::string newElement_0CtorSignature = "(J)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(newElement_0ClassName.c_str(), + newElement_0CtorSignature.c_str(), entry_0, newElement_0); + chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0); + } + + env->ExceptionClear(); + env->CallVoidMethod(javaCallbackRef, javaMethod, arrayListObj); +} + +CHIPSmokeCoAlarmEventListAttributeCallback::CHIPSmokeCoAlarmEventListAttributeCallback(jobject javaCallback, bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPSmokeCoAlarmEventListAttributeCallback::~CHIPSmokeCoAlarmEventListAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPSmokeCoAlarmEventListAttributeCallback::CallbackFn(void * context, + const chip::app::DataModel::DecodableList & list) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/util/List;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject arrayListObj; + chip::JniReferences::GetInstance().CreateArrayList(arrayListObj); + + auto iter_arrayListObj_0 = list.begin(); + while (iter_arrayListObj_0.Next()) + { + auto & entry_0 = iter_arrayListObj_0.GetValue(); + jobject newElement_0; + std::string newElement_0ClassName = "java/lang/Long"; + std::string newElement_0CtorSignature = "(J)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(newElement_0ClassName.c_str(), + newElement_0CtorSignature.c_str(), entry_0, newElement_0); + chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0); + } + + env->ExceptionClear(); + env->CallVoidMethod(javaCallbackRef, javaMethod, arrayListObj); +} + +CHIPSmokeCoAlarmAttributeListAttributeCallback::CHIPSmokeCoAlarmAttributeListAttributeCallback(jobject javaCallback, + bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPSmokeCoAlarmAttributeListAttributeCallback::~CHIPSmokeCoAlarmAttributeListAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPSmokeCoAlarmAttributeListAttributeCallback::CallbackFn(void * context, + const chip::app::DataModel::DecodableList & list) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/util/List;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject arrayListObj; + chip::JniReferences::GetInstance().CreateArrayList(arrayListObj); + + auto iter_arrayListObj_0 = list.begin(); + while (iter_arrayListObj_0.Next()) + { + auto & entry_0 = iter_arrayListObj_0.GetValue(); + jobject newElement_0; + std::string newElement_0ClassName = "java/lang/Long"; + std::string newElement_0CtorSignature = "(J)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(newElement_0ClassName.c_str(), + newElement_0CtorSignature.c_str(), entry_0, newElement_0); + chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0); + } + + env->ExceptionClear(); + env->CallVoidMethod(javaCallbackRef, javaMethod, arrayListObj); +} + CHIPHepaFilterMonitoringGeneratedCommandListAttributeCallback::CHIPHepaFilterMonitoringGeneratedCommandListAttributeCallback( jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java index e03fffda2bed94..623796c403b61f 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java @@ -13107,6 +13107,357 @@ private native void subscribeClusterRevisionAttribute( long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } + public static class SmokeCoAlarmCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 92L; + + public SmokeCoAlarmCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void selfTestRequest(DefaultClusterCallback callback) { + selfTestRequest(chipClusterPtr, callback, null); + } + + public void selfTestRequest(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { + + selfTestRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + private native void selfTestRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + public interface GeneratedCommandListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public interface AcceptedCommandListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public interface EventListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readExpressedStateAttribute(IntegerAttributeCallback callback) { + readExpressedStateAttribute(chipClusterPtr, callback); + } + + public void subscribeExpressedStateAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeExpressedStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSmokeStateAttribute(IntegerAttributeCallback callback) { + readSmokeStateAttribute(chipClusterPtr, callback); + } + + public void subscribeSmokeStateAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeSmokeStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCOStateAttribute(IntegerAttributeCallback callback) { + readCOStateAttribute(chipClusterPtr, callback); + } + + public void subscribeCOStateAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeCOStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBatteryAlertAttribute(IntegerAttributeCallback callback) { + readBatteryAlertAttribute(chipClusterPtr, callback); + } + + public void subscribeBatteryAlertAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeBatteryAlertAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readDeviceMutedAttribute(IntegerAttributeCallback callback) { + readDeviceMutedAttribute(chipClusterPtr, callback); + } + + public void subscribeDeviceMutedAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeDeviceMutedAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTestInProgressAttribute(BooleanAttributeCallback callback) { + readTestInProgressAttribute(chipClusterPtr, callback); + } + + public void subscribeTestInProgressAttribute( + BooleanAttributeCallback callback, int minInterval, int maxInterval) { + subscribeTestInProgressAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readHardwareFaultAlertAttribute(BooleanAttributeCallback callback) { + readHardwareFaultAlertAttribute(chipClusterPtr, callback); + } + + public void subscribeHardwareFaultAlertAttribute( + BooleanAttributeCallback callback, int minInterval, int maxInterval) { + subscribeHardwareFaultAlertAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEndOfServiceAlertAttribute(IntegerAttributeCallback callback) { + readEndOfServiceAlertAttribute(chipClusterPtr, callback); + } + + public void subscribeEndOfServiceAlertAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeEndOfServiceAlertAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readInterconnectSmokeAlarmAttribute(IntegerAttributeCallback callback) { + readInterconnectSmokeAlarmAttribute(chipClusterPtr, callback); + } + + public void subscribeInterconnectSmokeAlarmAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeInterconnectSmokeAlarmAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readInterconnectCOAlarmAttribute(IntegerAttributeCallback callback) { + readInterconnectCOAlarmAttribute(chipClusterPtr, callback); + } + + public void subscribeInterconnectCOAlarmAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeInterconnectCOAlarmAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readContaminationStateAttribute(IntegerAttributeCallback callback) { + readContaminationStateAttribute(chipClusterPtr, callback); + } + + public void subscribeContaminationStateAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeContaminationStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSensitivityLevelAttribute(IntegerAttributeCallback callback) { + readSensitivityLevelAttribute(chipClusterPtr, callback); + } + + public void writeSensitivityLevelAttribute(DefaultClusterCallback callback, Integer value) { + writeSensitivityLevelAttribute(chipClusterPtr, callback, value, null); + } + + public void writeSensitivityLevelAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeSensitivityLevelAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + + public void subscribeSensitivityLevelAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeSensitivityLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute(GeneratedCommandListAttributeCallback callback) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute(AcceptedCommandListAttributeCallback callback) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute(EventListAttributeCallback callback) { + readEventListAttribute(chipClusterPtr, callback); + } + + public void subscribeEventListAttribute( + EventListAttributeCallback callback, int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + readAttributeListAttribute(chipClusterPtr, callback); + } + + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute(LongAttributeCallback callback) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback, int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readExpressedStateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeExpressedStateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSmokeStateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeSmokeStateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCOStateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeCOStateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBatteryAlertAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeBatteryAlertAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readDeviceMutedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeDeviceMutedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTestInProgressAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void subscribeTestInProgressAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readHardwareFaultAlertAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void subscribeHardwareFaultAlertAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readEndOfServiceAlertAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeEndOfServiceAlertAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInterconnectSmokeAlarmAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeInterconnectSmokeAlarmAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInterconnectCOAlarmAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeInterconnectCOAlarmAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readContaminationStateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeContaminationStateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSensitivityLevelAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeSensitivityLevelAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeSensitivityLevelAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute( + long chipClusterPtr, GeneratedCommandListAttributeCallback callback); + + private native void subscribeGeneratedCommandListAttribute( + long chipClusterPtr, + GeneratedCommandListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readAcceptedCommandListAttribute( + long chipClusterPtr, AcceptedCommandListAttributeCallback callback); + + private native void subscribeAcceptedCommandListAttribute( + long chipClusterPtr, + AcceptedCommandListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readEventListAttribute( + long chipClusterPtr, EventListAttributeCallback callback); + + private native void subscribeEventListAttribute( + long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval); + + private native void readAttributeListAttribute( + long chipClusterPtr, AttributeListAttributeCallback callback); + + private native void subscribeAttributeListAttribute( + long chipClusterPtr, + AttributeListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readFeatureMapAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeFeatureMapAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + } + public static class HepaFilterMonitoringCluster extends BaseChipCluster { public static final long CLUSTER_ID = 113L; diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipEventStructs.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipEventStructs.java index 9f079111c14841..4bdf0c29f08bb5 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ChipEventStructs.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipEventStructs.java @@ -881,6 +881,149 @@ public String toString() { } } + public static class SmokeCoAlarmClusterSmokeAlarmEvent { + + public SmokeCoAlarmClusterSmokeAlarmEvent() {} + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("SmokeCoAlarmClusterSmokeAlarmEvent {\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class SmokeCoAlarmClusterCOAlarmEvent { + + public SmokeCoAlarmClusterCOAlarmEvent() {} + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("SmokeCoAlarmClusterCOAlarmEvent {\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class SmokeCoAlarmClusterLowBatteryEvent { + + public SmokeCoAlarmClusterLowBatteryEvent() {} + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("SmokeCoAlarmClusterLowBatteryEvent {\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class SmokeCoAlarmClusterHardwareFaultEvent { + + public SmokeCoAlarmClusterHardwareFaultEvent() {} + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("SmokeCoAlarmClusterHardwareFaultEvent {\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class SmokeCoAlarmClusterEndOfServiceEvent { + + public SmokeCoAlarmClusterEndOfServiceEvent() {} + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("SmokeCoAlarmClusterEndOfServiceEvent {\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class SmokeCoAlarmClusterSelfTestCompleteEvent { + + public SmokeCoAlarmClusterSelfTestCompleteEvent() {} + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("SmokeCoAlarmClusterSelfTestCompleteEvent {\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class SmokeCoAlarmClusterAlarmMutedEvent { + + public SmokeCoAlarmClusterAlarmMutedEvent() {} + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("SmokeCoAlarmClusterAlarmMutedEvent {\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class SmokeCoAlarmClusterMuteEndedEvent { + + public SmokeCoAlarmClusterMuteEndedEvent() {} + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("SmokeCoAlarmClusterMuteEndedEvent {\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class SmokeCoAlarmClusterInterconnectSmokeAlarmEvent { + + public SmokeCoAlarmClusterInterconnectSmokeAlarmEvent() {} + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("SmokeCoAlarmClusterInterconnectSmokeAlarmEvent {\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class SmokeCoAlarmClusterInterconnectCOAlarmEvent { + + public SmokeCoAlarmClusterInterconnectCOAlarmEvent() {} + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("SmokeCoAlarmClusterInterconnectCOAlarmEvent {\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class SmokeCoAlarmClusterAllClearEvent { + + public SmokeCoAlarmClusterAllClearEvent() {} + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("SmokeCoAlarmClusterAllClearEvent {\n"); + output.append("}\n"); + return output.toString(); + } + } + public static class DoorLockClusterDoorLockAlarmEvent { public Integer alarmCode; diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipIdLookup.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipIdLookup.java index 2d67c350f0886c..267bb5a6c65506 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ChipIdLookup.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipIdLookup.java @@ -139,6 +139,9 @@ public static String clusterIdToName(long clusterId) { if (clusterId == 91L) { return "AirQuality"; } + if (clusterId == 92L) { + return "SmokeCoAlarm"; + } if (clusterId == 113L) { return "HepaFilterMonitoring"; } @@ -1890,6 +1893,63 @@ public static String attributeIdToName(long clusterId, long attributeId) { } return ""; } + if (clusterId == 92L) { + if (attributeId == 0L) { + return "ExpressedState"; + } + if (attributeId == 1L) { + return "SmokeState"; + } + if (attributeId == 2L) { + return "COState"; + } + if (attributeId == 3L) { + return "BatteryAlert"; + } + if (attributeId == 4L) { + return "DeviceMuted"; + } + if (attributeId == 5L) { + return "TestInProgress"; + } + if (attributeId == 6L) { + return "HardwareFaultAlert"; + } + if (attributeId == 7L) { + return "EndOfServiceAlert"; + } + if (attributeId == 8L) { + return "InterconnectSmokeAlarm"; + } + if (attributeId == 9L) { + return "InterconnectCOAlarm"; + } + if (attributeId == 10L) { + return "ContaminationState"; + } + if (attributeId == 11L) { + return "SensitivityLevel"; + } + if (attributeId == 65528L) { + return "GeneratedCommandList"; + } + if (attributeId == 65529L) { + return "AcceptedCommandList"; + } + if (attributeId == 65530L) { + return "EventList"; + } + if (attributeId == 65531L) { + return "AttributeList"; + } + if (attributeId == 65532L) { + return "FeatureMap"; + } + if (attributeId == 65533L) { + return "ClusterRevision"; + } + return ""; + } if (clusterId == 113L) { if (attributeId == 0L) { return "Condition"; @@ -4616,6 +4676,42 @@ public static String eventIdToName(long clusterId, long eventId) { if (clusterId == 91L) { return ""; } + if (clusterId == 92L) { + if (eventId == 0L) { + return "SmokeAlarm"; + } + if (eventId == 1L) { + return "COAlarm"; + } + if (eventId == 2L) { + return "LowBattery"; + } + if (eventId == 3L) { + return "HardwareFault"; + } + if (eventId == 4L) { + return "EndOfService"; + } + if (eventId == 5L) { + return "SelfTestComplete"; + } + if (eventId == 6L) { + return "AlarmMuted"; + } + if (eventId == 7L) { + return "MuteEnded"; + } + if (eventId == 8L) { + return "InterconnectSmokeAlarm"; + } + if (eventId == 9L) { + return "InterconnectCOAlarm"; + } + if (eventId == 10L) { + return "AllClear"; + } + return ""; + } if (clusterId == 113L) { return ""; } diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java index bb0c456fba3fe9..f333763566362c 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java @@ -6858,6 +6858,102 @@ public void onError(Exception ex) { } } + public static class DelegatedSmokeCoAlarmClusterGeneratedCommandListAttributeCallback + implements ChipClusters.SmokeCoAlarmCluster.GeneratedCommandListAttributeCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(List valueList) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo commandResponseInfo = new CommandResponseInfo("valueList", "List"); + responseValues.put(commandResponseInfo, valueList); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception ex) { + callback.onFailure(ex); + } + } + + public static class DelegatedSmokeCoAlarmClusterAcceptedCommandListAttributeCallback + implements ChipClusters.SmokeCoAlarmCluster.AcceptedCommandListAttributeCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(List valueList) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo commandResponseInfo = new CommandResponseInfo("valueList", "List"); + responseValues.put(commandResponseInfo, valueList); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception ex) { + callback.onFailure(ex); + } + } + + public static class DelegatedSmokeCoAlarmClusterEventListAttributeCallback + implements ChipClusters.SmokeCoAlarmCluster.EventListAttributeCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(List valueList) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo commandResponseInfo = new CommandResponseInfo("valueList", "List"); + responseValues.put(commandResponseInfo, valueList); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception ex) { + callback.onFailure(ex); + } + } + + public static class DelegatedSmokeCoAlarmClusterAttributeListAttributeCallback + implements ChipClusters.SmokeCoAlarmCluster.AttributeListAttributeCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(List valueList) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo commandResponseInfo = new CommandResponseInfo("valueList", "List"); + responseValues.put(commandResponseInfo, valueList); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception ex) { + callback.onFailure(ex); + } + } + public static class DelegatedHepaFilterMonitoringClusterGeneratedCommandListAttributeCallback implements ChipClusters.HepaFilterMonitoringCluster.GeneratedCommandListAttributeCallback, DelegatedClusterCallback { @@ -14730,6 +14826,11 @@ public Map initializeClusterMap() { (ptr, endpointId) -> new ChipClusters.AirQualityCluster(ptr, endpointId), new HashMap<>()); clusterMap.put("airQuality", airQualityClusterInfo); + ClusterInfo smokeCoAlarmClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.SmokeCoAlarmCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("smokeCoAlarm", smokeCoAlarmClusterInfo); ClusterInfo hepaFilterMonitoringClusterInfo = new ClusterInfo( (ptr, endpointId) -> new ChipClusters.HepaFilterMonitoringCluster(ptr, endpointId), @@ -15001,6 +15102,7 @@ public void combineCommand( destination.get("icdManagement").combineCommands(source.get("icdManagement")); destination.get("modeSelect").combineCommands(source.get("modeSelect")); destination.get("airQuality").combineCommands(source.get("airQuality")); + destination.get("smokeCoAlarm").combineCommands(source.get("smokeCoAlarm")); destination.get("hepaFilterMonitoring").combineCommands(source.get("hepaFilterMonitoring")); destination .get("activatedCarbonFilterMonitoring") @@ -17146,6 +17248,20 @@ public Map> getCommandMap() { commandMap.put("modeSelect", modeSelectClusterInteractionInfoMap); Map airQualityClusterInteractionInfoMap = new LinkedHashMap<>(); commandMap.put("airQuality", airQualityClusterInteractionInfoMap); + Map smokeCoAlarmClusterInteractionInfoMap = new LinkedHashMap<>(); + Map smokeCoAlarmselfTestRequestCommandParams = + new LinkedHashMap(); + InteractionInfo smokeCoAlarmselfTestRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SmokeCoAlarmCluster) cluster) + .selfTestRequest((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + smokeCoAlarmselfTestRequestCommandParams); + smokeCoAlarmClusterInteractionInfoMap.put( + "selfTestRequest", smokeCoAlarmselfTestRequestInteractionInfo); + commandMap.put("smokeCoAlarm", smokeCoAlarmClusterInteractionInfoMap); Map hepaFilterMonitoringClusterInteractionInfoMap = new LinkedHashMap<>(); commandMap.put("hepaFilterMonitoring", hepaFilterMonitoringClusterInteractionInfoMap); diff --git a/src/controller/python/chip/clusters/CHIPClusters.py b/src/controller/python/chip/clusters/CHIPClusters.py index 16a413ea55902b..b81327408a5a33 100644 --- a/src/controller/python/chip/clusters/CHIPClusters.py +++ b/src/controller/python/chip/clusters/CHIPClusters.py @@ -4026,6 +4026,129 @@ class ChipClusters: }, }, } + _SMOKE_CO_ALARM_CLUSTER_INFO = { + "clusterName": "SmokeCoAlarm", + "clusterId": 0x0000005C, + "commands": { + 0x00000000: { + "commandId": 0x00000000, + "commandName": "SelfTestRequest", + "args": { + }, + }, + }, + "attributes": { + 0x00000000: { + "attributeName": "ExpressedState", + "attributeId": 0x00000000, + "type": "int", + "reportable": True, + }, + 0x00000001: { + "attributeName": "SmokeState", + "attributeId": 0x00000001, + "type": "int", + "reportable": True, + }, + 0x00000002: { + "attributeName": "COState", + "attributeId": 0x00000002, + "type": "int", + "reportable": True, + }, + 0x00000003: { + "attributeName": "BatteryAlert", + "attributeId": 0x00000003, + "type": "int", + "reportable": True, + }, + 0x00000004: { + "attributeName": "DeviceMuted", + "attributeId": 0x00000004, + "type": "int", + "reportable": True, + }, + 0x00000005: { + "attributeName": "TestInProgress", + "attributeId": 0x00000005, + "type": "bool", + "reportable": True, + }, + 0x00000006: { + "attributeName": "HardwareFaultAlert", + "attributeId": 0x00000006, + "type": "bool", + "reportable": True, + }, + 0x00000007: { + "attributeName": "EndOfServiceAlert", + "attributeId": 0x00000007, + "type": "int", + "reportable": True, + }, + 0x00000008: { + "attributeName": "InterconnectSmokeAlarm", + "attributeId": 0x00000008, + "type": "int", + "reportable": True, + }, + 0x00000009: { + "attributeName": "InterconnectCOAlarm", + "attributeId": 0x00000009, + "type": "int", + "reportable": True, + }, + 0x0000000A: { + "attributeName": "ContaminationState", + "attributeId": 0x0000000A, + "type": "int", + "reportable": True, + }, + 0x0000000B: { + "attributeName": "SensitivityLevel", + "attributeId": 0x0000000B, + "type": "int", + "reportable": True, + "writable": True, + }, + 0x0000FFF8: { + "attributeName": "GeneratedCommandList", + "attributeId": 0x0000FFF8, + "type": "int", + "reportable": True, + }, + 0x0000FFF9: { + "attributeName": "AcceptedCommandList", + "attributeId": 0x0000FFF9, + "type": "int", + "reportable": True, + }, + 0x0000FFFA: { + "attributeName": "EventList", + "attributeId": 0x0000FFFA, + "type": "int", + "reportable": True, + }, + 0x0000FFFB: { + "attributeName": "AttributeList", + "attributeId": 0x0000FFFB, + "type": "int", + "reportable": True, + }, + 0x0000FFFC: { + "attributeName": "FeatureMap", + "attributeId": 0x0000FFFC, + "type": "int", + "reportable": True, + }, + 0x0000FFFD: { + "attributeName": "ClusterRevision", + "attributeId": 0x0000FFFD, + "type": "int", + "reportable": True, + }, + }, + } _HEPA_FILTER_MONITORING_CLUSTER_INFO = { "clusterName": "HepaFilterMonitoring", "clusterId": 0x00000071, @@ -10167,6 +10290,7 @@ class ChipClusters: 0x00000046: _ICD_MANAGEMENT_CLUSTER_INFO, 0x00000050: _MODE_SELECT_CLUSTER_INFO, 0x0000005B: _AIR_QUALITY_CLUSTER_INFO, + 0x0000005C: _SMOKE_CO_ALARM_CLUSTER_INFO, 0x00000071: _HEPA_FILTER_MONITORING_CLUSTER_INFO, 0x00000072: _ACTIVATED_CARBON_FILTER_MONITORING_CLUSTER_INFO, 0x00000073: _CERAMIC_FILTER_MONITORING_CLUSTER_INFO, @@ -10249,6 +10373,7 @@ class ChipClusters: "IcdManagement": _ICD_MANAGEMENT_CLUSTER_INFO, "ModeSelect": _MODE_SELECT_CLUSTER_INFO, "AirQuality": _AIR_QUALITY_CLUSTER_INFO, + "SmokeCoAlarm": _SMOKE_CO_ALARM_CLUSTER_INFO, "HepaFilterMonitoring": _HEPA_FILTER_MONITORING_CLUSTER_INFO, "ActivatedCarbonFilterMonitoring": _ACTIVATED_CARBON_FILTER_MONITORING_CLUSTER_INFO, "CeramicFilterMonitoring": _CERAMIC_FILTER_MONITORING_CLUSTER_INFO, diff --git a/zzz_generated/darwin/controller-clusters/zap-generated/CHIPClientCallbacks.h b/zzz_generated/darwin/controller-clusters/zap-generated/CHIPClientCallbacks.h index e89b063e68bb99..01c46405758d23 100644 --- a/zzz_generated/darwin/controller-clusters/zap-generated/CHIPClientCallbacks.h +++ b/zzz_generated/darwin/controller-clusters/zap-generated/CHIPClientCallbacks.h @@ -19,8 +19,8 @@ #pragma once -#include #include +#include #include #include #include @@ -29,371 +29,781 @@ #include // List specific responses -typedef void (*IdentifyGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*IdentifyAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*IdentifyEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*IdentifyAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*GroupsGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*GroupsAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*GroupsEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*GroupsAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ScenesGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ScenesAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ScenesEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ScenesAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*OnOffGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*OnOffAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*OnOffEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*OnOffAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*OnOffSwitchConfigurationGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*OnOffSwitchConfigurationAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*OnOffSwitchConfigurationEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*OnOffSwitchConfigurationAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*LevelControlGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*LevelControlAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*LevelControlEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*LevelControlAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*BinaryInputBasicGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*BinaryInputBasicAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*BinaryInputBasicEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*BinaryInputBasicAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*DescriptorDeviceTypeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*DescriptorServerListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*DescriptorClientListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*DescriptorPartsListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*DescriptorGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*DescriptorAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*DescriptorEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*DescriptorAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*BindingBindingListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*BindingGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*BindingAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*BindingEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*BindingAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*AccessControlAclListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*AccessControlExtensionListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*AccessControlGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*AccessControlAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*AccessControlEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*AccessControlAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ActionsActionListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ActionsEndpointListsListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ActionsGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ActionsAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ActionsEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ActionsAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*BasicInformationGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*BasicInformationAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*BasicInformationEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*BasicInformationAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*OtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*OtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*OtaSoftwareUpdateProviderEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*OtaSoftwareUpdateProviderAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*OtaSoftwareUpdateRequestorDefaultOTAProvidersListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*OtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*OtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*OtaSoftwareUpdateRequestorEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*OtaSoftwareUpdateRequestorAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*LocalizationConfigurationSupportedLocalesListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*LocalizationConfigurationGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*LocalizationConfigurationAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*LocalizationConfigurationEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*LocalizationConfigurationAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*TimeFormatLocalizationSupportedCalendarTypesListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*TimeFormatLocalizationGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*TimeFormatLocalizationAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*TimeFormatLocalizationEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*TimeFormatLocalizationAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*UnitLocalizationGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*UnitLocalizationAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*UnitLocalizationEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*UnitLocalizationAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*PowerSourceConfigurationSourcesListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*PowerSourceConfigurationGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*PowerSourceConfigurationAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*PowerSourceConfigurationEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*PowerSourceConfigurationAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*PowerSourceActiveWiredFaultsListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*PowerSourceActiveBatFaultsListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*PowerSourceActiveBatChargeFaultsListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*PowerSourceGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*PowerSourceAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*PowerSourceEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*PowerSourceAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*GeneralCommissioningGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*GeneralCommissioningAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*GeneralCommissioningEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*GeneralCommissioningAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*NetworkCommissioningNetworksListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*NetworkCommissioningGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*NetworkCommissioningAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*NetworkCommissioningEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*NetworkCommissioningAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*DiagnosticLogsGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*DiagnosticLogsAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*DiagnosticLogsEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*DiagnosticLogsAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*GeneralDiagnosticsNetworkInterfacesListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*GeneralDiagnosticsActiveHardwareFaultsListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*GeneralDiagnosticsActiveRadioFaultsListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*GeneralDiagnosticsActiveNetworkFaultsListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*GeneralDiagnosticsGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*GeneralDiagnosticsAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*GeneralDiagnosticsEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*GeneralDiagnosticsAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*SoftwareDiagnosticsThreadMetricsListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*SoftwareDiagnosticsGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*SoftwareDiagnosticsAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*SoftwareDiagnosticsEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*SoftwareDiagnosticsAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ThreadNetworkDiagnosticsNeighborTableListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ThreadNetworkDiagnosticsRouteTableListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ThreadNetworkDiagnosticsEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ThreadNetworkDiagnosticsAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*WiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*WiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*WiFiNetworkDiagnosticsEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*WiFiNetworkDiagnosticsAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*EthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*EthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*EthernetNetworkDiagnosticsEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*EthernetNetworkDiagnosticsAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*BridgedDeviceBasicInformationGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*BridgedDeviceBasicInformationAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*BridgedDeviceBasicInformationEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*BridgedDeviceBasicInformationAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*SwitchGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*SwitchAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*SwitchEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*SwitchAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*AdministratorCommissioningGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*AdministratorCommissioningAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*AdministratorCommissioningEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*AdministratorCommissioningAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*OperationalCredentialsNOCsListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*OperationalCredentialsFabricsListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*OperationalCredentialsTrustedRootCertificatesListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*OperationalCredentialsGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*OperationalCredentialsAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*OperationalCredentialsEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*OperationalCredentialsAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*GroupKeyManagementGroupKeyMapListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*GroupKeyManagementGroupTableListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*GroupKeyManagementGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*GroupKeyManagementAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*GroupKeyManagementEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*GroupKeyManagementAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*FixedLabelLabelListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*FixedLabelGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*FixedLabelAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*FixedLabelEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*FixedLabelAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*UserLabelLabelListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*UserLabelGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*UserLabelAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*UserLabelEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*UserLabelAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*BooleanStateGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*BooleanStateAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*BooleanStateEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*BooleanStateAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*IcdManagementRegisteredClientsListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*IcdManagementGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*IcdManagementAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*IcdManagementEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*IcdManagementAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ModeSelectSupportedModesListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ModeSelectGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ModeSelectAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ModeSelectEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ModeSelectAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*AirQualityGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*AirQualityAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*AirQualityEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*AirQualityAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*SmokeCoAlarmGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*SmokeCoAlarmAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*SmokeCoAlarmEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*SmokeCoAlarmAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*HepaFilterMonitoringGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*HepaFilterMonitoringAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*HepaFilterMonitoringEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*HepaFilterMonitoringAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ActivatedCarbonFilterMonitoringGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ActivatedCarbonFilterMonitoringAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ActivatedCarbonFilterMonitoringEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ActivatedCarbonFilterMonitoringAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*CeramicFilterMonitoringGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*CeramicFilterMonitoringAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*CeramicFilterMonitoringEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*CeramicFilterMonitoringAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ElectrostaticFilterMonitoringGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ElectrostaticFilterMonitoringAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ElectrostaticFilterMonitoringEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ElectrostaticFilterMonitoringAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*UvFilterMonitoringGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*UvFilterMonitoringAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*UvFilterMonitoringEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*UvFilterMonitoringAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*IonizingFilterMonitoringGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*IonizingFilterMonitoringAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*IonizingFilterMonitoringEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*IonizingFilterMonitoringAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ZeoliteFilterMonitoringGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ZeoliteFilterMonitoringAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ZeoliteFilterMonitoringEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ZeoliteFilterMonitoringAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*OzoneFilterMonitoringGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*OzoneFilterMonitoringAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*OzoneFilterMonitoringEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*OzoneFilterMonitoringAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*WaterTankMonitoringGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*WaterTankMonitoringAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*WaterTankMonitoringEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*WaterTankMonitoringAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*FuelTankMonitoringGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*FuelTankMonitoringAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*FuelTankMonitoringEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*FuelTankMonitoringAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*InkCartridgeMonitoringGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*InkCartridgeMonitoringAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*InkCartridgeMonitoringEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*InkCartridgeMonitoringAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*TonerCartridgeMonitoringGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*TonerCartridgeMonitoringAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*TonerCartridgeMonitoringEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*TonerCartridgeMonitoringAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*DoorLockGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*DoorLockAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*DoorLockEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*DoorLockAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*WindowCoveringGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*WindowCoveringAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*WindowCoveringEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*WindowCoveringAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*BarrierControlGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*BarrierControlAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*BarrierControlEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*BarrierControlAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*PumpConfigurationAndControlGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*PumpConfigurationAndControlAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*PumpConfigurationAndControlEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*PumpConfigurationAndControlAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ThermostatGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ThermostatAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ThermostatEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ThermostatAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*FanControlGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*FanControlAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*FanControlEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*FanControlAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ThermostatUserInterfaceConfigurationEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ThermostatUserInterfaceConfigurationAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ColorControlGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ColorControlAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ColorControlEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ColorControlAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*BallastConfigurationGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*BallastConfigurationAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*BallastConfigurationEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*BallastConfigurationAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*IlluminanceMeasurementGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*IlluminanceMeasurementAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*IlluminanceMeasurementEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*IlluminanceMeasurementAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*TemperatureMeasurementGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*TemperatureMeasurementAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*TemperatureMeasurementEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*TemperatureMeasurementAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*PressureMeasurementGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*PressureMeasurementAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*PressureMeasurementEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*PressureMeasurementAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*FlowMeasurementGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*FlowMeasurementAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*FlowMeasurementEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*FlowMeasurementAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*RelativeHumidityMeasurementGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*RelativeHumidityMeasurementAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*RelativeHumidityMeasurementEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*RelativeHumidityMeasurementAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*OccupancySensingGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*OccupancySensingAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*OccupancySensingEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*OccupancySensingAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*WakeOnLanGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*WakeOnLanAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*WakeOnLanEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*WakeOnLanAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ChannelChannelListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ChannelGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ChannelAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ChannelEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ChannelAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*TargetNavigatorTargetListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*TargetNavigatorGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*TargetNavigatorAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*TargetNavigatorEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*TargetNavigatorAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*MediaPlaybackGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*MediaPlaybackAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*MediaPlaybackEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*MediaPlaybackAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*MediaInputInputListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*MediaInputGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*MediaInputAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*MediaInputEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*MediaInputAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*LowPowerGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*LowPowerAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*LowPowerEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*LowPowerAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*KeypadInputGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*KeypadInputAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*KeypadInputEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*KeypadInputAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ContentLauncherAcceptHeaderListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ContentLauncherGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ContentLauncherAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ContentLauncherEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ContentLauncherAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*AudioOutputOutputListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*AudioOutputGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*AudioOutputAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*AudioOutputEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*AudioOutputAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ApplicationLauncherCatalogListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ApplicationLauncherGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ApplicationLauncherAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ApplicationLauncherEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ApplicationLauncherAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ApplicationBasicAllowedVendorListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ApplicationBasicGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ApplicationBasicAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ApplicationBasicEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ApplicationBasicAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*AccountLoginGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*AccountLoginAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*AccountLoginEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*AccountLoginAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ElectricalMeasurementGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ElectricalMeasurementAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ElectricalMeasurementEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*ElectricalMeasurementAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*UnitTestingListInt8uListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*UnitTestingListOctetStringListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*UnitTestingListStructOctetStringListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*UnitTestingListNullablesAndOptionalsStructListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*UnitTestingListLongOctetStringListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*UnitTestingListFabricScopedListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*UnitTestingGeneratedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*UnitTestingAcceptedCommandListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*UnitTestingEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); -typedef void (*UnitTestingAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); - +typedef void (*IdentifyGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*IdentifyAcceptedCommandListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*IdentifyEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*IdentifyAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*GroupsGeneratedCommandListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*GroupsAcceptedCommandListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*GroupsEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*GroupsAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ScenesGeneratedCommandListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ScenesAcceptedCommandListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ScenesEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ScenesAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*OnOffGeneratedCommandListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*OnOffAcceptedCommandListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*OnOffEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*OnOffAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*OnOffSwitchConfigurationGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OnOffSwitchConfigurationAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OnOffSwitchConfigurationEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OnOffSwitchConfigurationAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*LevelControlGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*LevelControlAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*LevelControlEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*LevelControlAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*BinaryInputBasicGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*BinaryInputBasicAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*BinaryInputBasicEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*BinaryInputBasicAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*DescriptorDeviceTypeListListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*DescriptorServerListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*DescriptorClientListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*DescriptorPartsListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*DescriptorGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*DescriptorAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*DescriptorEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*DescriptorAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*BindingBindingListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*BindingGeneratedCommandListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*BindingAcceptedCommandListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*BindingEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*BindingAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*AccessControlAclListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList< + chip::app::Clusters::AccessControl::Structs::AccessControlEntryStruct::DecodableType> & data); +typedef void (*AccessControlExtensionListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList< + chip::app::Clusters::AccessControl::Structs::AccessControlExtensionStruct::DecodableType> & data); +typedef void (*AccessControlGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*AccessControlAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*AccessControlEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*AccessControlAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ActionsActionListListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ActionsEndpointListsListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ActionsGeneratedCommandListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ActionsAcceptedCommandListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ActionsEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ActionsAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*BasicInformationGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*BasicInformationAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*BasicInformationEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*BasicInformationAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OtaSoftwareUpdateProviderEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OtaSoftwareUpdateProviderAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OtaSoftwareUpdateRequestorDefaultOTAProvidersListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList< + chip::app::Clusters::OtaSoftwareUpdateRequestor::Structs::ProviderLocation::DecodableType> & data); +typedef void (*OtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OtaSoftwareUpdateRequestorEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OtaSoftwareUpdateRequestorAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*LocalizationConfigurationSupportedLocalesListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*LocalizationConfigurationGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*LocalizationConfigurationAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*LocalizationConfigurationEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*LocalizationConfigurationAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*TimeFormatLocalizationSupportedCalendarTypesListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*TimeFormatLocalizationGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*TimeFormatLocalizationAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*TimeFormatLocalizationEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*TimeFormatLocalizationAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*UnitLocalizationGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*UnitLocalizationAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*UnitLocalizationEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*UnitLocalizationAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*PowerSourceConfigurationSourcesListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*PowerSourceConfigurationGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*PowerSourceConfigurationAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*PowerSourceConfigurationEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*PowerSourceConfigurationAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*PowerSourceActiveWiredFaultsListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*PowerSourceActiveBatFaultsListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*PowerSourceActiveBatChargeFaultsListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*PowerSourceGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*PowerSourceAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*PowerSourceEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*PowerSourceAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*GeneralCommissioningGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*GeneralCommissioningAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*GeneralCommissioningEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*GeneralCommissioningAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*NetworkCommissioningNetworksListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & + data); +typedef void (*NetworkCommissioningGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*NetworkCommissioningAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*NetworkCommissioningEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*NetworkCommissioningAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*DiagnosticLogsGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*DiagnosticLogsAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*DiagnosticLogsEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*DiagnosticLogsAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*GeneralDiagnosticsNetworkInterfacesListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & + data); +typedef void (*GeneralDiagnosticsActiveHardwareFaultsListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*GeneralDiagnosticsActiveRadioFaultsListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*GeneralDiagnosticsActiveNetworkFaultsListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*GeneralDiagnosticsGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*GeneralDiagnosticsAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*GeneralDiagnosticsEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*GeneralDiagnosticsAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*SoftwareDiagnosticsThreadMetricsListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList< + chip::app::Clusters::SoftwareDiagnostics::Structs::ThreadMetricsStruct::DecodableType> & data); +typedef void (*SoftwareDiagnosticsGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*SoftwareDiagnosticsAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*SoftwareDiagnosticsEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*SoftwareDiagnosticsAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ThreadNetworkDiagnosticsNeighborTableListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList< + chip::app::Clusters::ThreadNetworkDiagnostics::Structs::NeighborTable::DecodableType> & data); +typedef void (*ThreadNetworkDiagnosticsRouteTableListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & + data); +typedef void (*ThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ThreadNetworkDiagnosticsEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ThreadNetworkDiagnosticsAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*WiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*WiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*WiFiNetworkDiagnosticsEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*WiFiNetworkDiagnosticsAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*EthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*EthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*EthernetNetworkDiagnosticsEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*EthernetNetworkDiagnosticsAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*BridgedDeviceBasicInformationGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*BridgedDeviceBasicInformationAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*BridgedDeviceBasicInformationEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*BridgedDeviceBasicInformationAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*SwitchGeneratedCommandListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*SwitchAcceptedCommandListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*SwitchEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*SwitchAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*AdministratorCommissioningGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*AdministratorCommissioningAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*AdministratorCommissioningEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*AdministratorCommissioningAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OperationalCredentialsNOCsListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & + data); +typedef void (*OperationalCredentialsFabricsListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList< + chip::app::Clusters::OperationalCredentials::Structs::FabricDescriptorStruct::DecodableType> & data); +typedef void (*OperationalCredentialsTrustedRootCertificatesListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OperationalCredentialsGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OperationalCredentialsAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OperationalCredentialsEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OperationalCredentialsAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*GroupKeyManagementGroupKeyMapListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & + data); +typedef void (*GroupKeyManagementGroupTableListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & + data); +typedef void (*GroupKeyManagementGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*GroupKeyManagementAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*GroupKeyManagementEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*GroupKeyManagementAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*FixedLabelLabelListListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*FixedLabelGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*FixedLabelAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*FixedLabelEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*FixedLabelAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*UserLabelLabelListListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*UserLabelGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*UserLabelAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*UserLabelEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*UserLabelAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*BooleanStateGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*BooleanStateAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*BooleanStateEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*BooleanStateAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*IcdManagementRegisteredClientsListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList< + chip::app::Clusters::IcdManagement::Structs::MonitoringRegistrationStruct::DecodableType> & data); +typedef void (*IcdManagementGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*IcdManagementAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*IcdManagementEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*IcdManagementAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ModeSelectSupportedModesListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ModeSelectGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ModeSelectAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ModeSelectEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ModeSelectAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*AirQualityGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*AirQualityAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*AirQualityEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*AirQualityAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*SmokeCoAlarmGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*SmokeCoAlarmAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*SmokeCoAlarmEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*SmokeCoAlarmAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*HepaFilterMonitoringGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*HepaFilterMonitoringAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*HepaFilterMonitoringEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*HepaFilterMonitoringAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ActivatedCarbonFilterMonitoringGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ActivatedCarbonFilterMonitoringAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ActivatedCarbonFilterMonitoringEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ActivatedCarbonFilterMonitoringAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*CeramicFilterMonitoringGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*CeramicFilterMonitoringAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*CeramicFilterMonitoringEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*CeramicFilterMonitoringAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ElectrostaticFilterMonitoringGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ElectrostaticFilterMonitoringAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ElectrostaticFilterMonitoringEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ElectrostaticFilterMonitoringAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*UvFilterMonitoringGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*UvFilterMonitoringAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*UvFilterMonitoringEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*UvFilterMonitoringAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*IonizingFilterMonitoringGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*IonizingFilterMonitoringAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*IonizingFilterMonitoringEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*IonizingFilterMonitoringAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ZeoliteFilterMonitoringGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ZeoliteFilterMonitoringAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ZeoliteFilterMonitoringEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ZeoliteFilterMonitoringAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OzoneFilterMonitoringGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OzoneFilterMonitoringAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OzoneFilterMonitoringEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OzoneFilterMonitoringAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*WaterTankMonitoringGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*WaterTankMonitoringAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*WaterTankMonitoringEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*WaterTankMonitoringAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*FuelTankMonitoringGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*FuelTankMonitoringAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*FuelTankMonitoringEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*FuelTankMonitoringAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*InkCartridgeMonitoringGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*InkCartridgeMonitoringAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*InkCartridgeMonitoringEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*InkCartridgeMonitoringAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*TonerCartridgeMonitoringGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*TonerCartridgeMonitoringAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*TonerCartridgeMonitoringEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*TonerCartridgeMonitoringAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*DoorLockGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*DoorLockAcceptedCommandListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*DoorLockEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*DoorLockAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*WindowCoveringGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*WindowCoveringAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*WindowCoveringEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*WindowCoveringAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*BarrierControlGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*BarrierControlAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*BarrierControlEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*BarrierControlAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*PumpConfigurationAndControlGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*PumpConfigurationAndControlAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*PumpConfigurationAndControlEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*PumpConfigurationAndControlAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ThermostatGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ThermostatAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ThermostatEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ThermostatAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*FanControlGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*FanControlAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*FanControlEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*FanControlAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ThermostatUserInterfaceConfigurationEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ThermostatUserInterfaceConfigurationAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ColorControlGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ColorControlAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ColorControlEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ColorControlAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*BallastConfigurationGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*BallastConfigurationAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*BallastConfigurationEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*BallastConfigurationAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*IlluminanceMeasurementGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*IlluminanceMeasurementAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*IlluminanceMeasurementEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*IlluminanceMeasurementAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*TemperatureMeasurementGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*TemperatureMeasurementAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*TemperatureMeasurementEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*TemperatureMeasurementAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*PressureMeasurementGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*PressureMeasurementAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*PressureMeasurementEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*PressureMeasurementAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*FlowMeasurementGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*FlowMeasurementAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*FlowMeasurementEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*FlowMeasurementAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*RelativeHumidityMeasurementGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*RelativeHumidityMeasurementAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*RelativeHumidityMeasurementEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*RelativeHumidityMeasurementAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OccupancySensingGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OccupancySensingAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*OccupancySensingEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*OccupancySensingAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*WakeOnLanGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*WakeOnLanAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*WakeOnLanEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*WakeOnLanAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ChannelChannelListListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ChannelGeneratedCommandListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ChannelAcceptedCommandListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ChannelEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ChannelAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*TargetNavigatorTargetListListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & + data); +typedef void (*TargetNavigatorGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*TargetNavigatorAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*TargetNavigatorEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*TargetNavigatorAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*MediaPlaybackGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*MediaPlaybackAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*MediaPlaybackEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*MediaPlaybackAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*MediaInputInputListListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*MediaInputGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*MediaInputAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*MediaInputEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*MediaInputAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*LowPowerGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*LowPowerAcceptedCommandListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*LowPowerEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*LowPowerAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*KeypadInputGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*KeypadInputAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*KeypadInputEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*KeypadInputAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ContentLauncherAcceptHeaderListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ContentLauncherGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ContentLauncherAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ContentLauncherEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ContentLauncherAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*AudioOutputOutputListListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*AudioOutputGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*AudioOutputAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*AudioOutputEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*AudioOutputAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ApplicationLauncherCatalogListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ApplicationLauncherGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ApplicationLauncherAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ApplicationLauncherEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ApplicationLauncherAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ApplicationBasicAllowedVendorListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ApplicationBasicGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ApplicationBasicAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ApplicationBasicEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ApplicationBasicAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*AccountLoginGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*AccountLoginAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*AccountLoginEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*AccountLoginAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*ElectricalMeasurementGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ElectricalMeasurementAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ElectricalMeasurementEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ElectricalMeasurementAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*UnitTestingListInt8uListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*UnitTestingListOctetStringListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*UnitTestingListStructOctetStringListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & + data); +typedef void (*UnitTestingListNullablesAndOptionalsStructListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList< + chip::app::Clusters::UnitTesting::Structs::NullablesAndOptionalsStruct::DecodableType> & data); +typedef void (*UnitTestingListLongOctetStringListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*UnitTestingListFabricScopedListAttributeCallback)( + void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*UnitTestingGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*UnitTestingAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*UnitTestingEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*UnitTestingAttributeListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); diff --git a/zzz_generated/darwin/controller-clusters/zap-generated/CHIPClusters.h b/zzz_generated/darwin/controller-clusters/zap-generated/CHIPClusters.h index fc6c997323d594..db17098cf93914 100644 --- a/zzz_generated/darwin/controller-clusters/zap-generated/CHIPClusters.h +++ b/zzz_generated/darwin/controller-clusters/zap-generated/CHIPClusters.h @@ -33,560 +33,744 @@ namespace Controller { class DLL_EXPORT IdentifyCluster : public ClusterBase { public: - IdentifyCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + IdentifyCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~IdentifyCluster() {} }; class DLL_EXPORT GroupsCluster : public ClusterBase { public: - GroupsCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + GroupsCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~GroupsCluster() {} }; class DLL_EXPORT ScenesCluster : public ClusterBase { public: - ScenesCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + ScenesCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~ScenesCluster() {} }; class DLL_EXPORT OnOffCluster : public ClusterBase { public: - OnOffCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + OnOffCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~OnOffCluster() {} }; class DLL_EXPORT OnOffSwitchConfigurationCluster : public ClusterBase { public: - OnOffSwitchConfigurationCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + OnOffSwitchConfigurationCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~OnOffSwitchConfigurationCluster() {} }; class DLL_EXPORT LevelControlCluster : public ClusterBase { public: - LevelControlCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + LevelControlCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~LevelControlCluster() {} }; class DLL_EXPORT BinaryInputBasicCluster : public ClusterBase { public: - BinaryInputBasicCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + BinaryInputBasicCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~BinaryInputBasicCluster() {} }; class DLL_EXPORT DescriptorCluster : public ClusterBase { public: - DescriptorCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + DescriptorCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~DescriptorCluster() {} }; class DLL_EXPORT BindingCluster : public ClusterBase { public: - BindingCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + BindingCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~BindingCluster() {} }; class DLL_EXPORT AccessControlCluster : public ClusterBase { public: - AccessControlCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + AccessControlCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~AccessControlCluster() {} }; class DLL_EXPORT ActionsCluster : public ClusterBase { public: - ActionsCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + ActionsCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~ActionsCluster() {} }; class DLL_EXPORT BasicInformationCluster : public ClusterBase { public: - BasicInformationCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + BasicInformationCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~BasicInformationCluster() {} }; class DLL_EXPORT OtaSoftwareUpdateProviderCluster : public ClusterBase { public: - OtaSoftwareUpdateProviderCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + OtaSoftwareUpdateProviderCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~OtaSoftwareUpdateProviderCluster() {} }; class DLL_EXPORT OtaSoftwareUpdateRequestorCluster : public ClusterBase { public: - OtaSoftwareUpdateRequestorCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + OtaSoftwareUpdateRequestorCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~OtaSoftwareUpdateRequestorCluster() {} }; class DLL_EXPORT LocalizationConfigurationCluster : public ClusterBase { public: - LocalizationConfigurationCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + LocalizationConfigurationCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~LocalizationConfigurationCluster() {} }; class DLL_EXPORT TimeFormatLocalizationCluster : public ClusterBase { public: - TimeFormatLocalizationCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + TimeFormatLocalizationCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~TimeFormatLocalizationCluster() {} }; class DLL_EXPORT UnitLocalizationCluster : public ClusterBase { public: - UnitLocalizationCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + UnitLocalizationCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~UnitLocalizationCluster() {} }; class DLL_EXPORT PowerSourceConfigurationCluster : public ClusterBase { public: - PowerSourceConfigurationCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + PowerSourceConfigurationCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~PowerSourceConfigurationCluster() {} }; class DLL_EXPORT PowerSourceCluster : public ClusterBase { public: - PowerSourceCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + PowerSourceCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~PowerSourceCluster() {} }; class DLL_EXPORT GeneralCommissioningCluster : public ClusterBase { public: - GeneralCommissioningCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + GeneralCommissioningCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~GeneralCommissioningCluster() {} }; class DLL_EXPORT NetworkCommissioningCluster : public ClusterBase { public: - NetworkCommissioningCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + NetworkCommissioningCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~NetworkCommissioningCluster() {} }; class DLL_EXPORT DiagnosticLogsCluster : public ClusterBase { public: - DiagnosticLogsCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + DiagnosticLogsCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~DiagnosticLogsCluster() {} }; class DLL_EXPORT GeneralDiagnosticsCluster : public ClusterBase { public: - GeneralDiagnosticsCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + GeneralDiagnosticsCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~GeneralDiagnosticsCluster() {} }; class DLL_EXPORT SoftwareDiagnosticsCluster : public ClusterBase { public: - SoftwareDiagnosticsCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + SoftwareDiagnosticsCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~SoftwareDiagnosticsCluster() {} }; class DLL_EXPORT ThreadNetworkDiagnosticsCluster : public ClusterBase { public: - ThreadNetworkDiagnosticsCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + ThreadNetworkDiagnosticsCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~ThreadNetworkDiagnosticsCluster() {} }; class DLL_EXPORT WiFiNetworkDiagnosticsCluster : public ClusterBase { public: - WiFiNetworkDiagnosticsCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + WiFiNetworkDiagnosticsCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~WiFiNetworkDiagnosticsCluster() {} }; class DLL_EXPORT EthernetNetworkDiagnosticsCluster : public ClusterBase { public: - EthernetNetworkDiagnosticsCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + EthernetNetworkDiagnosticsCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~EthernetNetworkDiagnosticsCluster() {} }; class DLL_EXPORT BridgedDeviceBasicInformationCluster : public ClusterBase { public: - BridgedDeviceBasicInformationCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + BridgedDeviceBasicInformationCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~BridgedDeviceBasicInformationCluster() {} }; class DLL_EXPORT SwitchCluster : public ClusterBase { public: - SwitchCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + SwitchCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~SwitchCluster() {} }; class DLL_EXPORT AdministratorCommissioningCluster : public ClusterBase { public: - AdministratorCommissioningCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + AdministratorCommissioningCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~AdministratorCommissioningCluster() {} }; class DLL_EXPORT OperationalCredentialsCluster : public ClusterBase { public: - OperationalCredentialsCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + OperationalCredentialsCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~OperationalCredentialsCluster() {} }; class DLL_EXPORT GroupKeyManagementCluster : public ClusterBase { public: - GroupKeyManagementCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + GroupKeyManagementCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~GroupKeyManagementCluster() {} }; class DLL_EXPORT FixedLabelCluster : public ClusterBase { public: - FixedLabelCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + FixedLabelCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~FixedLabelCluster() {} }; class DLL_EXPORT UserLabelCluster : public ClusterBase { public: - UserLabelCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + UserLabelCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~UserLabelCluster() {} }; class DLL_EXPORT BooleanStateCluster : public ClusterBase { public: - BooleanStateCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + BooleanStateCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~BooleanStateCluster() {} }; class DLL_EXPORT IcdManagementCluster : public ClusterBase { public: - IcdManagementCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + IcdManagementCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~IcdManagementCluster() {} }; class DLL_EXPORT ModeSelectCluster : public ClusterBase { public: - ModeSelectCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + ModeSelectCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~ModeSelectCluster() {} }; class DLL_EXPORT AirQualityCluster : public ClusterBase { public: - AirQualityCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + AirQualityCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~AirQualityCluster() {} }; class DLL_EXPORT SmokeCoAlarmCluster : public ClusterBase { public: - SmokeCoAlarmCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + SmokeCoAlarmCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~SmokeCoAlarmCluster() {} }; class DLL_EXPORT HepaFilterMonitoringCluster : public ClusterBase { public: - HepaFilterMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + HepaFilterMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~HepaFilterMonitoringCluster() {} }; class DLL_EXPORT ActivatedCarbonFilterMonitoringCluster : public ClusterBase { public: - ActivatedCarbonFilterMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + ActivatedCarbonFilterMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~ActivatedCarbonFilterMonitoringCluster() {} }; class DLL_EXPORT CeramicFilterMonitoringCluster : public ClusterBase { public: - CeramicFilterMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + CeramicFilterMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~CeramicFilterMonitoringCluster() {} }; class DLL_EXPORT ElectrostaticFilterMonitoringCluster : public ClusterBase { public: - ElectrostaticFilterMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + ElectrostaticFilterMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~ElectrostaticFilterMonitoringCluster() {} }; class DLL_EXPORT UvFilterMonitoringCluster : public ClusterBase { public: - UvFilterMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + UvFilterMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~UvFilterMonitoringCluster() {} }; class DLL_EXPORT IonizingFilterMonitoringCluster : public ClusterBase { public: - IonizingFilterMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + IonizingFilterMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~IonizingFilterMonitoringCluster() {} }; class DLL_EXPORT ZeoliteFilterMonitoringCluster : public ClusterBase { public: - ZeoliteFilterMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + ZeoliteFilterMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~ZeoliteFilterMonitoringCluster() {} }; class DLL_EXPORT OzoneFilterMonitoringCluster : public ClusterBase { public: - OzoneFilterMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + OzoneFilterMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~OzoneFilterMonitoringCluster() {} }; class DLL_EXPORT WaterTankMonitoringCluster : public ClusterBase { public: - WaterTankMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + WaterTankMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~WaterTankMonitoringCluster() {} }; class DLL_EXPORT FuelTankMonitoringCluster : public ClusterBase { public: - FuelTankMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + FuelTankMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~FuelTankMonitoringCluster() {} }; class DLL_EXPORT InkCartridgeMonitoringCluster : public ClusterBase { public: - InkCartridgeMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + InkCartridgeMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~InkCartridgeMonitoringCluster() {} }; class DLL_EXPORT TonerCartridgeMonitoringCluster : public ClusterBase { public: - TonerCartridgeMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + TonerCartridgeMonitoringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~TonerCartridgeMonitoringCluster() {} }; class DLL_EXPORT DoorLockCluster : public ClusterBase { public: - DoorLockCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + DoorLockCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~DoorLockCluster() {} }; class DLL_EXPORT WindowCoveringCluster : public ClusterBase { public: - WindowCoveringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + WindowCoveringCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~WindowCoveringCluster() {} }; class DLL_EXPORT BarrierControlCluster : public ClusterBase { public: - BarrierControlCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + BarrierControlCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~BarrierControlCluster() {} }; class DLL_EXPORT PumpConfigurationAndControlCluster : public ClusterBase { public: - PumpConfigurationAndControlCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + PumpConfigurationAndControlCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~PumpConfigurationAndControlCluster() {} }; class DLL_EXPORT ThermostatCluster : public ClusterBase { public: - ThermostatCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + ThermostatCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~ThermostatCluster() {} }; class DLL_EXPORT FanControlCluster : public ClusterBase { public: - FanControlCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + FanControlCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~FanControlCluster() {} }; class DLL_EXPORT ThermostatUserInterfaceConfigurationCluster : public ClusterBase { public: - ThermostatUserInterfaceConfigurationCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + ThermostatUserInterfaceConfigurationCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~ThermostatUserInterfaceConfigurationCluster() {} }; class DLL_EXPORT ColorControlCluster : public ClusterBase { public: - ColorControlCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + ColorControlCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~ColorControlCluster() {} }; class DLL_EXPORT BallastConfigurationCluster : public ClusterBase { public: - BallastConfigurationCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + BallastConfigurationCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~BallastConfigurationCluster() {} }; class DLL_EXPORT IlluminanceMeasurementCluster : public ClusterBase { public: - IlluminanceMeasurementCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + IlluminanceMeasurementCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~IlluminanceMeasurementCluster() {} }; class DLL_EXPORT TemperatureMeasurementCluster : public ClusterBase { public: - TemperatureMeasurementCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + TemperatureMeasurementCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~TemperatureMeasurementCluster() {} }; class DLL_EXPORT PressureMeasurementCluster : public ClusterBase { public: - PressureMeasurementCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + PressureMeasurementCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~PressureMeasurementCluster() {} }; class DLL_EXPORT FlowMeasurementCluster : public ClusterBase { public: - FlowMeasurementCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + FlowMeasurementCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~FlowMeasurementCluster() {} }; class DLL_EXPORT RelativeHumidityMeasurementCluster : public ClusterBase { public: - RelativeHumidityMeasurementCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + RelativeHumidityMeasurementCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, + EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~RelativeHumidityMeasurementCluster() {} }; class DLL_EXPORT OccupancySensingCluster : public ClusterBase { public: - OccupancySensingCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + OccupancySensingCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~OccupancySensingCluster() {} }; class DLL_EXPORT WakeOnLanCluster : public ClusterBase { public: - WakeOnLanCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + WakeOnLanCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~WakeOnLanCluster() {} }; class DLL_EXPORT ChannelCluster : public ClusterBase { public: - ChannelCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + ChannelCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~ChannelCluster() {} }; class DLL_EXPORT TargetNavigatorCluster : public ClusterBase { public: - TargetNavigatorCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + TargetNavigatorCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~TargetNavigatorCluster() {} }; class DLL_EXPORT MediaPlaybackCluster : public ClusterBase { public: - MediaPlaybackCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + MediaPlaybackCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~MediaPlaybackCluster() {} }; class DLL_EXPORT MediaInputCluster : public ClusterBase { public: - MediaInputCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + MediaInputCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~MediaInputCluster() {} }; class DLL_EXPORT LowPowerCluster : public ClusterBase { public: - LowPowerCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + LowPowerCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~LowPowerCluster() {} }; class DLL_EXPORT KeypadInputCluster : public ClusterBase { public: - KeypadInputCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + KeypadInputCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~KeypadInputCluster() {} }; class DLL_EXPORT ContentLauncherCluster : public ClusterBase { public: - ContentLauncherCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + ContentLauncherCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~ContentLauncherCluster() {} }; class DLL_EXPORT AudioOutputCluster : public ClusterBase { public: - AudioOutputCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + AudioOutputCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~AudioOutputCluster() {} }; class DLL_EXPORT ApplicationLauncherCluster : public ClusterBase { public: - ApplicationLauncherCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + ApplicationLauncherCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~ApplicationLauncherCluster() {} }; class DLL_EXPORT ApplicationBasicCluster : public ClusterBase { public: - ApplicationBasicCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + ApplicationBasicCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~ApplicationBasicCluster() {} }; class DLL_EXPORT AccountLoginCluster : public ClusterBase { public: - AccountLoginCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + AccountLoginCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~AccountLoginCluster() {} }; class DLL_EXPORT ElectricalMeasurementCluster : public ClusterBase { public: - ElectricalMeasurementCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + ElectricalMeasurementCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~ElectricalMeasurementCluster() {} }; class DLL_EXPORT UnitTestingCluster : public ClusterBase { public: - UnitTestingCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint) {} + UnitTestingCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} ~UnitTestingCluster() {} }; diff --git a/zzz_generated/darwin/controller-clusters/zap-generated/IMClusterCommandHandler.cpp b/zzz_generated/darwin/controller-clusters/zap-generated/IMClusterCommandHandler.cpp index eeff908b8f7356..2a1289be1113cc 100644 --- a/zzz_generated/darwin/controller-clusters/zap-generated/IMClusterCommandHandler.cpp +++ b/zzz_generated/darwin/controller-clusters/zap-generated/IMClusterCommandHandler.cpp @@ -17,16 +17,16 @@ // THIS FILE IS GENERATED BY ZAP -#include #include +#include #include #include #include #include -#include #include #include +#include #include #include @@ -35,10 +35,7 @@ namespace app { // Cluster specific command parsing -namespace Clusters { - - -} // namespace Clusters +namespace Clusters {} // namespace Clusters void DispatchSingleClusterCommand(const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aReader, CommandHandler * apCommandObj) { @@ -46,10 +43,7 @@ void DispatchSingleClusterCommand(const ConcreteCommandPath & aCommandPath, TLV: { default: ChipLogError(Zcl, "Unknown cluster " ChipLogFormatMEI, ChipLogValueMEI(aCommandPath.mClusterId)); - apCommandObj->AddStatus( - aCommandPath, - Protocols::InteractionModel::Status::UnsupportedCluster - ); + apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCluster); break; } } diff --git a/zzz_generated/darwin/controller-clusters/zap-generated/endpoint_config.h b/zzz_generated/darwin/controller-clusters/zap-generated/endpoint_config.h index b911435bd2f265..345ab29adbfc03 100644 --- a/zzz_generated/darwin/controller-clusters/zap-generated/endpoint_config.h +++ b/zzz_generated/darwin/controller-clusters/zap-generated/endpoint_config.h @@ -20,21 +20,19 @@ // Prevent multiple inclusion #pragma once -#include #include - +#include // Default values for the attributes longer than a pointer, // in a form of a binary blob // Separate block is generated for big-endian and little-endian cases. #if BIGENDIAN_CPU -#define GENERATED_DEFAULTS { \ -} - +#define GENERATED_DEFAULTS \ + {} #else // !BIGENDIAN_CPU -#define GENERATED_DEFAULTS { \ -} +#define GENERATED_DEFAULTS \ + {} #endif // BIGENDIAN_CPU @@ -42,15 +40,13 @@ // This is an array of EmberAfAttributeMinMaxValue structures. #define GENERATED_MIN_MAX_DEFAULT_COUNT 0 -#define GENERATED_MIN_MAX_DEFAULTS { \ -} - +#define GENERATED_MIN_MAX_DEFAULTS \ + {} // This is an array of EmberAfAttributeMetadata structures. #define GENERATED_ATTRIBUTE_COUNT 0 -#define GENERATED_ATTRIBUTES { \ -} - +#define GENERATED_ATTRIBUTES \ + {} // clang-format off #define GENERATED_EVENT_COUNT 0 @@ -60,10 +56,7 @@ // clang-format on // Cluster function static arrays -#define GENERATED_FUNCTION_ARRAYS \ - - - +#define GENERATED_FUNCTION_ARRAYS // This is an array of EmberAfCluster structures. #define GENERATED_CLUSTER_COUNT 80 @@ -1116,17 +1109,15 @@ #define ZAP_FIXED_ENDPOINT_DATA_VERSION_COUNT 0 // This is an array of EmberAfEndpointType structures. -#define GENERATED_ENDPOINT_TYPES { \ - { ZAP_CLUSTER_INDEX(0), 80, 0 }, \ -} - - +#define GENERATED_ENDPOINT_TYPES \ + { \ + { ZAP_CLUSTER_INDEX(0), 80, 0 }, \ + } // Largest attribute size is needed for various buffers #define ATTRIBUTE_LARGEST (1) -static_assert(ATTRIBUTE_LARGEST <= CHIP_CONFIG_MAX_ATTRIBUTE_STORE_ELEMENT_SIZE, - "ATTRIBUTE_LARGEST larger than expected"); +static_assert(ATTRIBUTE_LARGEST <= CHIP_CONFIG_MAX_ATTRIBUTE_STORE_ELEMENT_SIZE, "ATTRIBUTE_LARGEST larger than expected"); // Total size of singleton attributes #define ATTRIBUTE_SINGLETONS_SIZE (0) @@ -1139,23 +1130,45 @@ static_assert(ATTRIBUTE_LARGEST <= CHIP_CONFIG_MAX_ATTRIBUTE_STORE_ELEMENT_SIZE, // Array of endpoints that are supported, the data inside // the array is the endpoint number. -#define FIXED_ENDPOINT_ARRAY { 0x0001 } +#define FIXED_ENDPOINT_ARRAY \ + { \ + 0x0001 \ + } // Array of profile ids -#define FIXED_PROFILE_IDS { 0x0103 } +#define FIXED_PROFILE_IDS \ + { \ + 0x0103 \ + } // Array of device types -#define FIXED_DEVICE_TYPES {{0x0016,1}} +#define FIXED_DEVICE_TYPES \ + { \ + { \ + 0x0016, 1 \ + } \ + } // Array of device type offsets -#define FIXED_DEVICE_TYPE_OFFSETS { 0} +#define FIXED_DEVICE_TYPE_OFFSETS \ + { \ + 0 \ + } // Array of device type lengths -#define FIXED_DEVICE_TYPE_LENGTHS { 1} +#define FIXED_DEVICE_TYPE_LENGTHS \ + { \ + 1 \ + } // Array of endpoint types supported on each endpoint -#define FIXED_ENDPOINT_TYPES { 0 } +#define FIXED_ENDPOINT_TYPES \ + { \ + 0 \ + } // Array of networks supported on each endpoint -#define FIXED_NETWORKS { 0 } - +#define FIXED_NETWORKS \ + { \ + 0 \ + } diff --git a/zzz_generated/darwin/controller-clusters/zap-generated/gen_config.h b/zzz_generated/darwin/controller-clusters/zap-generated/gen_config.h index f6ac5c3d63dd0e..92890866b64a9c 100644 --- a/zzz_generated/darwin/controller-clusters/zap-generated/gen_config.h +++ b/zzz_generated/darwin/controller-clusters/zap-generated/gen_config.h @@ -108,398 +108,318 @@ #define ZCL_USING_IDENTIFY_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_IDENTIFY_CLIENT - // Use this macro to check if the client side of the Groups cluster is included #define ZCL_USING_GROUPS_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_GROUPS_CLIENT - // Use this macro to check if the client side of the Scenes cluster is included #define ZCL_USING_SCENES_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_SCENES_CLIENT - // Use this macro to check if the client side of the On/Off cluster is included #define ZCL_USING_ON_OFF_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_ON_OFF_CLIENT - // Use this macro to check if the client side of the On/off Switch Configuration cluster is included #define ZCL_USING_ON_OFF_SWITCH_CONFIGURATION_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_ON_OFF_SWITCH_CONFIGURATION_CLIENT - // Use this macro to check if the client side of the Level Control cluster is included #define ZCL_USING_LEVEL_CONTROL_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_LEVEL_CONTROL_CLIENT - // Use this macro to check if the client side of the Binary Input (Basic) cluster is included #define ZCL_USING_BINARY_INPUT_BASIC_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_BINARY_INPUT_BASIC_CLIENT - // Use this macro to check if the client side of the Descriptor cluster is included #define ZCL_USING_DESCRIPTOR_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_DESCRIPTOR_CLIENT - // Use this macro to check if the client side of the Binding cluster is included #define ZCL_USING_BINDING_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_BINDING_CLIENT - // Use this macro to check if the client side of the Access Control cluster is included #define ZCL_USING_ACCESS_CONTROL_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_ACCESS_CONTROL_CLIENT - // Use this macro to check if the client side of the Actions cluster is included #define ZCL_USING_ACTIONS_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_ACTIONS_CLIENT - // Use this macro to check if the client side of the Basic Information cluster is included #define ZCL_USING_BASIC_INFORMATION_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_BASIC_INFORMATION_CLIENT - // Use this macro to check if the client side of the OTA Software Update Provider cluster is included #define ZCL_USING_OTA_SOFTWARE_UPDATE_PROVIDER_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_OTA_SOFTWARE_UPDATE_PROVIDER_CLIENT - // Use this macro to check if the client side of the OTA Software Update Requestor cluster is included #define ZCL_USING_OTA_SOFTWARE_UPDATE_REQUESTOR_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_OTA_SOFTWARE_UPDATE_REQUESTOR_CLIENT - // Use this macro to check if the client side of the Localization Configuration cluster is included #define ZCL_USING_LOCALIZATION_CONFIGURATION_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_LOCALIZATION_CONFIGURATION_CLIENT - // Use this macro to check if the client side of the Time Format Localization cluster is included #define ZCL_USING_TIME_FORMAT_LOCALIZATION_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_TIME_FORMAT_LOCALIZATION_CLIENT - // Use this macro to check if the client side of the Unit Localization cluster is included #define ZCL_USING_UNIT_LOCALIZATION_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_UNIT_LOCALIZATION_CLIENT - // Use this macro to check if the client side of the Power Source Configuration cluster is included #define ZCL_USING_POWER_SOURCE_CONFIGURATION_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_POWER_SOURCE_CONFIGURATION_CLIENT - // Use this macro to check if the client side of the Power Source cluster is included #define ZCL_USING_POWER_SOURCE_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_POWER_SOURCE_CLIENT - // Use this macro to check if the client side of the General Commissioning cluster is included #define ZCL_USING_GENERAL_COMMISSIONING_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_GENERAL_COMMISSIONING_CLIENT - // Use this macro to check if the client side of the Network Commissioning cluster is included #define ZCL_USING_NETWORK_COMMISSIONING_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_NETWORK_COMMISSIONING_CLIENT - // Use this macro to check if the client side of the Diagnostic Logs cluster is included #define ZCL_USING_DIAGNOSTIC_LOGS_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_DIAGNOSTIC_LOGS_CLIENT - // Use this macro to check if the client side of the General Diagnostics cluster is included #define ZCL_USING_GENERAL_DIAGNOSTICS_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_GENERAL_DIAGNOSTICS_CLIENT - // Use this macro to check if the client side of the Software Diagnostics cluster is included #define ZCL_USING_SOFTWARE_DIAGNOSTICS_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_SOFTWARE_DIAGNOSTICS_CLIENT - // Use this macro to check if the client side of the Thread Network Diagnostics cluster is included #define ZCL_USING_THREAD_NETWORK_DIAGNOSTICS_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_THREAD_NETWORK_DIAGNOSTICS_CLIENT - // Use this macro to check if the client side of the WiFi Network Diagnostics cluster is included #define ZCL_USING_WIFI_NETWORK_DIAGNOSTICS_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_WI_FI_NETWORK_DIAGNOSTICS_CLIENT - // Use this macro to check if the client side of the Ethernet Network Diagnostics cluster is included #define ZCL_USING_ETHERNET_NETWORK_DIAGNOSTICS_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_ETHERNET_NETWORK_DIAGNOSTICS_CLIENT - // Use this macro to check if the client side of the Bridged Device Basic Information cluster is included #define ZCL_USING_BRIDGED_DEVICE_BASIC_INFORMATION_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_BRIDGED_DEVICE_BASIC_INFORMATION_CLIENT - // Use this macro to check if the client side of the Switch cluster is included #define ZCL_USING_SWITCH_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_SWITCH_CLIENT - // Use this macro to check if the client side of the Administrator Commissioning cluster is included #define ZCL_USING_ADMINISTRATOR_COMMISSIONING_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_ADMINISTRATOR_COMMISSIONING_CLIENT - // Use this macro to check if the client side of the Operational Credentials cluster is included #define ZCL_USING_OPERATIONAL_CREDENTIALS_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_OPERATIONAL_CREDENTIALS_CLIENT - // Use this macro to check if the client side of the Group Key Management cluster is included #define ZCL_USING_GROUP_KEY_MANAGEMENT_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_GROUP_KEY_MANAGEMENT_CLIENT - // Use this macro to check if the client side of the Fixed Label cluster is included #define ZCL_USING_FIXED_LABEL_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_FIXED_LABEL_CLIENT - // Use this macro to check if the client side of the User Label cluster is included #define ZCL_USING_USER_LABEL_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_USER_LABEL_CLIENT - // Use this macro to check if the client side of the Boolean State cluster is included #define ZCL_USING_BOOLEAN_STATE_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_BOOLEAN_STATE_CLIENT - // Use this macro to check if the client side of the ICD Management cluster is included #define ZCL_USING_ICD_MANAGEMENT_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_ICD_MANAGEMENT_CLIENT - // Use this macro to check if the client side of the Mode Select cluster is included #define ZCL_USING_MODE_SELECT_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_MODE_SELECT_CLIENT - // Use this macro to check if the client side of the Air Quality cluster is included #define ZCL_USING_AIR_QUALITY_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_AIR_QUALITY_CLIENT - // Use this macro to check if the client side of the Smoke CO Alarm cluster is included #define ZCL_USING_SMOKE_CO_ALARM_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_SMOKE_CO_ALARM_CLIENT - // Use this macro to check if the client side of the HEPA Filter Monitoring cluster is included #define ZCL_USING_HEPA_FILTER_MONITORING_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_HEPA_FILTER_MONITORING_CLIENT - // Use this macro to check if the client side of the Activated Carbon Filter Monitoring cluster is included #define ZCL_USING_ACTIVATED_CARBON_FILTER_MONITORING_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_ACTIVATED_CARBON_FILTER_MONITORING_CLIENT - // Use this macro to check if the client side of the Ceramic Filter Monitoring cluster is included #define ZCL_USING_CERAMIC_FILTER_MONITORING_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_CERAMIC_FILTER_MONITORING_CLIENT - // Use this macro to check if the client side of the Electrostatic Filter Monitoring cluster is included #define ZCL_USING_ELECTROSTATIC_FILTER_MONITORING_CLIENT #define EMBER_AF_PLUGIN_ELECTROSTATIC_FILTER_MONITORING_CLIENT - // Use this macro to check if the client side of the UV Filter Monitoring cluster is included #define ZCL_USING_UV_FILTER_MONITORING_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_UV_FILTER_MONITORING_CLIENT - // Use this macro to check if the client side of the Ionizing Filter Monitoring cluster is included #define ZCL_USING_IONIZING_FILTER_MONITORING_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_IONIZING_FILTER_MONITORING_CLIENT - // Use this macro to check if the client side of the Zeolite Filter Monitoring cluster is included #define ZCL_USING_ZEOLITE_FILTER_MONITORING_CLIENT #define EMBER_AF_PLUGIN_ZEOLITE_FILTER_MONITORING_CLIENT - // Use this macro to check if the client side of the Ozone Filter Monitoring cluster is included #define ZCL_USING_OZONE_FILTER_MONITORING_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_OZONE_FILTER_MONITORING_CLIENT - // Use this macro to check if the client side of the Water Tank Monitoring cluster is included #define ZCL_USING_WATER_TANK_MONITORING_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_WATER_TANK_MONITORING_CLIENT - // Use this macro to check if the client side of the Fuel Tank Monitoring cluster is included #define ZCL_USING_FUEL_TANK_MONITORING_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_FUEL_TANK_MONITORING_CLIENT - // Use this macro to check if the client side of the Ink Cartridge Monitoring cluster is included #define ZCL_USING_INK_CARTRIDGE_MONITORING_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_INK_CARTRIDGE_MONITORING_CLIENT - // Use this macro to check if the client side of the Toner Cartridge Monitoring cluster is included #define ZCL_USING_TONER_CARTRIDGE_MONITORING_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_TONER_CARTRIDGE_MONITORING_CLIENT - // Use this macro to check if the client side of the Door Lock cluster is included #define ZCL_USING_DOOR_LOCK_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_DOOR_LOCK_CLIENT - // Use this macro to check if the client side of the Window Covering cluster is included #define ZCL_USING_WINDOW_COVERING_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_WINDOW_COVERING_CLIENT - // Use this macro to check if the client side of the Barrier Control cluster is included #define ZCL_USING_BARRIER_CONTROL_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_BARRIER_CONTROL_CLIENT - // Use this macro to check if the client side of the Pump Configuration and Control cluster is included #define ZCL_USING_PUMP_CONFIGURATION_AND_CONTROL_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_PUMP_CONFIGURATION_AND_CONTROL_CLIENT - // Use this macro to check if the client side of the Thermostat cluster is included #define ZCL_USING_THERMOSTAT_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_THERMOSTAT_CLIENT - // Use this macro to check if the client side of the Fan Control cluster is included #define ZCL_USING_FAN_CONTROL_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_FAN_CONTROL_CLIENT - // Use this macro to check if the client side of the Thermostat User Interface Configuration cluster is included #define ZCL_USING_THERMOSTAT_USER_INTERFACE_CONFIGURATION_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_THERMOSTAT_USER_INTERFACE_CONFIGURATION_CLIENT - // Use this macro to check if the client side of the Color Control cluster is included #define ZCL_USING_COLOR_CONTROL_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_COLOR_CONTROL_CLIENT - // Use this macro to check if the client side of the Ballast Configuration cluster is included #define ZCL_USING_BALLAST_CONFIGURATION_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_BALLAST_CONFIGURATION_CLIENT - // Use this macro to check if the client side of the Illuminance Measurement cluster is included #define ZCL_USING_ILLUMINANCE_MEASUREMENT_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_ILLUMINANCE_MEASUREMENT_CLIENT - // Use this macro to check if the client side of the Temperature Measurement cluster is included #define ZCL_USING_TEMPERATURE_MEASUREMENT_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_TEMPERATURE_MEASUREMENT_CLIENT - // Use this macro to check if the client side of the Pressure Measurement cluster is included #define ZCL_USING_PRESSURE_MEASUREMENT_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_PRESSURE_MEASUREMENT_CLIENT - // Use this macro to check if the client side of the Flow Measurement cluster is included #define ZCL_USING_FLOW_MEASUREMENT_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_FLOW_MEASUREMENT_CLIENT - // Use this macro to check if the client side of the Relative Humidity Measurement cluster is included #define ZCL_USING_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_RELATIVE_HUMIDITY_MEASUREMENT_CLIENT - // Use this macro to check if the client side of the Occupancy Sensing cluster is included #define ZCL_USING_OCCUPANCY_SENSING_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_OCCUPANCY_SENSING_CLIENT - // Use this macro to check if the client side of the Wake on LAN cluster is included #define ZCL_USING_WAKE_ON_LAN_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_WAKE_ON_LAN_CLIENT - // Use this macro to check if the client side of the Channel cluster is included #define ZCL_USING_CHANNEL_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_CHANNEL_CLIENT - // Use this macro to check if the client side of the Target Navigator cluster is included #define ZCL_USING_TARGET_NAVIGATOR_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_TARGET_NAVIGATOR_CLIENT - // Use this macro to check if the client side of the Media Playback cluster is included #define ZCL_USING_MEDIA_PLAYBACK_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_MEDIA_PLAYBACK_CLIENT - // Use this macro to check if the client side of the Media Input cluster is included #define ZCL_USING_MEDIA_INPUT_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_MEDIA_INPUT_CLIENT - // Use this macro to check if the client side of the Low Power cluster is included #define ZCL_USING_LOW_POWER_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_LOW_POWER_CLIENT - // Use this macro to check if the client side of the Keypad Input cluster is included #define ZCL_USING_KEYPAD_INPUT_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_KEYPAD_INPUT_CLIENT - // Use this macro to check if the client side of the Content Launcher cluster is included #define ZCL_USING_CONTENT_LAUNCHER_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_CONTENT_LAUNCHER_CLIENT - // Use this macro to check if the client side of the Audio Output cluster is included #define ZCL_USING_AUDIO_OUTPUT_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_AUDIO_OUTPUT_CLIENT - // Use this macro to check if the client side of the Application Launcher cluster is included #define ZCL_USING_APPLICATION_LAUNCHER_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_APPLICATION_LAUNCHER_CLIENT - // Use this macro to check if the client side of the Application Basic cluster is included #define ZCL_USING_APPLICATION_BASIC_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_APPLICATION_BASIC_CLIENT - // Use this macro to check if the client side of the Account Login cluster is included #define ZCL_USING_ACCOUNT_LOGIN_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_ACCOUNT_LOGIN_CLIENT - // Use this macro to check if the client side of the Electrical Measurement cluster is included #define ZCL_USING_ELECTRICAL_MEASUREMENT_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_ELECTRICAL_MEASUREMENT_CLIENT - // Use this macro to check if the client side of the Unit Testing cluster is included #define ZCL_USING_UNIT_TESTING_CLUSTER_CLIENT #define EMBER_AF_PLUGIN_UNIT_TESTING_CLIENT -